diff options
Diffstat (limited to 'src')
53 files changed, 7632 insertions, 6813 deletions
diff --git a/src/AgbRfu_LinkManager.c b/src/AgbRfu_LinkManager.c new file mode 100644 index 000000000..e4127ee09 --- /dev/null +++ b/src/AgbRfu_LinkManager.c @@ -0,0 +1,1398 @@ +#include "global.h" +#include "librfu.h" +#include "link_rfu.h" + +#define RN_ACCEPT 0x01 +#define RN_NAME_TIMER_CLEAR 0x02 +#define RN_DISCONNECT 0x04 + +#define LINK_RECOVERY_OFF 0x00 +#define LINK_RECOVERY_START 0x01 +#define LINK_RECOVERY_EXE 0x02 +#define LINK_RECOVERY_IMPOSSIBLE 0x04 + +#define FSP_ON 0x01 +#define FSP_START 0x02 + +LINK_MANAGER lman; + +static void rfu_LMAN_clearVariables(void); +static void rfu_LMAN_settingPCSWITCH(u32 rand); +static void rfu_LMAN_REQ_callback(u16 reqCommandId, u16 reqResult); +static void rfu_LMAN_MSC_callback(u16 reqCommandId); +static void rfu_LMAN_PARENT_checkRecvChildName(void); +static void rfu_LMAN_CHILD_checkSendChildName(void); +static void rfu_LMAN_CHILD_checkSendChildName2(void); +static void rfu_LMAN_CHILD_linkRecoveryProcess(void); +static u8 rfu_LMAN_CHILD_checkEnableParentCandidate(void); +static void rfu_LMAN_occureCallback(u8 msg, u8 param_count); +static void rfu_LMAN_disconnect(u8 bmDisconnectSlot); +static void rfu_LMAN_reflectCommunicationStatus(u8 bm_disconnectedSlot); +static void rfu_LMAN_checkNICommunicateStatus(void); +static void rfu_LMAN_managerChangeAgbClockMaster(void); + +u32 rfu_LMAN_REQBN_softReset_and_checkID(void) +{ + u32 id = rfu_REQBN_softReset_and_checkID(); + if (id == RFU_ID) + lman.RFU_powerOn_flag = 1; + if (lman.state != LMAN_FORCED_STOP_AND_RFU_RESET && lman.state != LMAN_STATE_SOFT_RESET_AND_CHECK_ID) + { + lman.state = lman.next_state = LMAN_STATE_READY; + } + lman.pcswitch_flag = 0; + lman.reserveDisconnectSlot_flag = 0; + lman.acceptCount = 0; + lman.acceptSlot_flag = 0; + lman.parent_child = MODE_NEUTRAL; + rfu_LMAN_managerChangeAgbClockMaster(); + return id; +} + +void rfu_LMAN_REQ_sendData(u8 clockChangeFlag) +{ + if (gRfuLinkStatus->parentChild == MODE_CHILD) + { + if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON) + clockChangeFlag = TRUE; + else + clockChangeFlag = FALSE; + } + else + lman.parentAck_flag = 0; + rfu_REQ_sendData(clockChangeFlag); +} + +u8 rfu_LMAN_initializeManager(void (*LMAN_callback_p)(u8, u8), void (*MSC_callback_p)(u16)) +{ + if (LMAN_callback_p == NULL) + { + return LMAN_ERROR_ILLEGAL_PARAMETER; + } + CpuFill16(0, &lman, sizeof(struct linkManagerTag)); + lman.parent_child = MODE_NEUTRAL; + lman.LMAN_callback = LMAN_callback_p; + lman.MSC_callback = MSC_callback_p; + rfu_setMSCCallback(rfu_LMAN_MSC_callback); + rfu_setREQCallback(rfu_LMAN_REQ_callback); + return 0; +} + +static void rfu_LMAN_endManager(void) +{ + CpuFill16(0, &lman, sizeof(struct linkManagerTag) - 8); + lman.parent_child = MODE_NEUTRAL; +} + +void rfu_LMAN_initializeRFU(INIT_PARAM *init_parameters) +{ + rfu_LMAN_clearVariables(); + lman.state = LMAN_STATE_SOFT_RESET_AND_CHECK_ID; + lman.next_state = LMAN_STATE_RESET; + lman.init_param = init_parameters; + lman.linkRecovery_enable = init_parameters->linkRecovery_enable; + lman.linkRecoveryTimer.count_max = init_parameters->linkRecovery_period; + lman.NI_failCounter_limit = init_parameters->NI_failCounter_limit; + if (init_parameters->fastSearchParent_flag) + { + lman.fastSearchParent_flag = FSP_ON; + } +} + +static void rfu_LMAN_clearVariables(void) +{ + u8 i; + + lman.state = lman.next_state = LMAN_STATE_READY; + lman.parent_child = MODE_NEUTRAL; + lman.pcswitch_flag = 0; + lman.child_slot = 0; + lman.connectSlot_flag_old = 0; + lman.nameAcceptTimer.active = 0; + lman.linkRecoveryTimer.active = 0; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + lman.nameAcceptTimer.count[i] = 0; + lman.linkRecoveryTimer.count[i] = 0; + } +} + +void rfu_LMAN_powerDownRFU(void) +{ + lman.state = LMAN_STATE_STOP_MODE; +} + +u8 rfu_LMAN_establishConnection(u8 parent_child, u16 connect_period, u16 name_accept_period, u16 *acceptable_serialNo_list) +{ + u8 i; + u16 *serial_list; + + if (lman.state != LMAN_STATE_READY && (lman.state != LMAN_STATE_WAIT_RECV_CHILD_NAME || parent_child != MODE_PARENT)) + { + lman.param[0] = 1; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_MANAGER_BUSY; + } + if (rfu_getMasterSlave() == AGB_CLK_SLAVE) + { + lman.param[0] = 2; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_AGB_CLK_SLAVE; + } + for (i = 0, serial_list = acceptable_serialNo_list; i < 16; i++) + { + if (*serial_list++ == 0xFFFF) + { + break; + } + } + if (i == 16) + { + lman.param[0] = 4; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_ILLEGAL_PARAMETER; + } + if (parent_child > MODE_PARENT) + { + lman.pcswitch_flag = PCSWITCH_1ST_SC_START; + parent_child = MODE_PARENT; + connect_period = 0; + } + else + { + lman.pcswitch_flag = 0; + } + if (parent_child != MODE_CHILD) + { + lman.state = LMAN_STATE_START_SEARCH_CHILD; + } + else + { + lman.state = LMAN_STATE_START_SEARCH_PARENT; + if (lman.fastSearchParent_flag) + { + lman.fastSearchParent_flag = FSP_START; + } + } + lman.parent_child = parent_child; + lman.connect_period = connect_period; + lman.nameAcceptTimer.count_max = name_accept_period; + lman.acceptable_serialNo_list = acceptable_serialNo_list; + return 0; +} + +u8 rfu_LMAN_CHILD_connectParent(u16 parentId, u16 connect_period) +{ + u8 i; + + if (lman.state != LMAN_STATE_READY && (lman.state < 9 || lman.state > 11)) + { + lman.param[0] = 1; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_MANAGER_BUSY; + } + if (rfu_getMasterSlave() == AGB_CLK_SLAVE) + { + lman.param[0] = 2; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_AGB_CLK_SLAVE; + } + for (i = 0; i < gRfuLinkStatus->findParentCount; i++) + { + if (gRfuLinkStatus->partner[i].id == parentId) + { + break; + } + } + if (gRfuLinkStatus->findParentCount == 0 || i == gRfuLinkStatus->findParentCount) + { + lman.param[0] = 3; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_PID_NOT_FOUND; + } + if (lman.state == LMAN_STATE_READY || lman.state == LMAN_STATE_START_SEARCH_PARENT) + { + lman.state = LMAN_STATE_START_CONNECT_PARENT; + lman.next_state = LMAN_STATE_POLL_CONNECT_PARENT; + } + else + { + lman.state = LMAN_STATE_END_SEARCH_PARENT; + lman.next_state = LMAN_STATE_START_CONNECT_PARENT; + } + lman.work = parentId; + lman.connect_period = connect_period; + if (lman.pcswitch_flag != 0) + { + lman.pcswitch_flag = PCSWITCH_CP; + } + return 0; +} + +static void rfu_LMAN_PARENT_stopWaitLinkRecoveryAndDisconnect(u8 bm_targetSlot) +{ + u8 i; + + if ((bm_targetSlot & lman.linkRecoveryTimer.active) == 0) + return; + lman.linkRecoveryTimer.active &= ~bm_targetSlot; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((bm_targetSlot >> i) & 1) + { + lman.linkRecoveryTimer.count[i] = 0; + } + } + i = gRfuLinkStatus->linkLossSlotFlag & bm_targetSlot; + if (i) + { + rfu_LMAN_disconnect(i); + } + lman.param[0] = i; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, i); +} + +void rfu_LMAN_stopManager(u8 forced_stop_and_RFU_reset_flag) +{ + u8 msg = 0; + lman.pcswitch_flag = 0; + if (forced_stop_and_RFU_reset_flag) + { + rfu_LMAN_clearVariables(); + lman.state = LMAN_FORCED_STOP_AND_RFU_RESET; + return; + } + switch (lman.state) + { + case LMAN_STATE_START_SEARCH_CHILD: + lman.state = LMAN_STATE_WAIT_RECV_CHILD_NAME; + lman.next_state = LMAN_STATE_READY; + msg = LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED; + break; + case LMAN_STATE_POLL_SEARCH_CHILD: + lman.state = LMAN_STATE_END_SEARCH_CHILD; + lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME; + break; + case LMAN_STATE_END_SEARCH_CHILD: + lman.state = LMAN_STATE_END_SEARCH_CHILD; + lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME; + break; + case LMAN_STATE_WAIT_RECV_CHILD_NAME: + break; + case LMAN_STATE_START_SEARCH_PARENT: + lman.state = lman.next_state = LMAN_STATE_READY; + msg = LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED; + break; + case LMAN_STATE_POLL_SEARCH_PARENT: + lman.state = LMAN_STATE_END_SEARCH_PARENT; + lman.next_state = LMAN_STATE_READY; + break; + case LMAN_STATE_END_SEARCH_PARENT: + lman.state = LMAN_STATE_END_SEARCH_PARENT; + lman.next_state = LMAN_STATE_READY; + break; + case LMAN_STATE_START_CONNECT_PARENT: + lman.state = lman.next_state = LMAN_STATE_READY; + msg = LMAN_MSG_CONNECT_PARENT_FAILED; + break; + case LMAN_STATE_POLL_CONNECT_PARENT: + lman.state = LMAN_STATE_END_CONNECT_PARENT; + break; + case LMAN_STATE_END_CONNECT_PARENT: + lman.state = LMAN_STATE_END_CONNECT_PARENT; + break; + case LMAN_STATE_SEND_CHILD_NAME: + break; + case LMAN_STATE_START_LINK_RECOVERY: + lman.state = lman.state_bak[0]; + lman.next_state = lman.state_bak[1]; + rfu_LMAN_disconnect(gRfuLinkStatus->linkLossSlotFlag); + lman.param[0] = gRfuLinkStatus->linkLossSlotFlag; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1); + return; + case LMAN_STATE_POLL_LINK_RECOVERY: + lman.state = LMAN_STATE_END_LINK_RECOVERY; + break; + case LMAN_STATE_END_LINK_RECOVERY: + lman.state = LMAN_STATE_END_LINK_RECOVERY; + break; + default: + lman.state = lman.next_state = LMAN_STATE_READY; + msg = LMAN_MSG_MANAGER_STOPPED; + break; + } + if (lman.state == LMAN_STATE_READY) + { + rfu_LMAN_occureCallback(msg, 0); + } +} + +static bool8 rfu_LMAN_linkWatcher(u16 REQ_commandID) +{ + u8 i; + u8 bm_linkLossSlot; + u8 reason; + u8 bm_linkRecoverySlot; + u8 bm_disconnectSlot; + + bool8 disconnect_occure_flag = FALSE; + rfu_REQBN_watchLink(REQ_commandID, &bm_linkLossSlot, &reason, &bm_linkRecoverySlot); + if (bm_linkLossSlot) + { + lman.param[0] = bm_linkLossSlot; + lman.param[1] = reason; + if (lman.linkRecovery_enable) + { + lman.linkRecovery_start_flag = LINK_RECOVERY_START; + if (lman.parent_child == MODE_CHILD && reason == REASON_DISCONNECTED) + { + lman.linkRecovery_start_flag = LINK_RECOVERY_IMPOSSIBLE; + } + if (lman.linkRecovery_start_flag == LINK_RECOVERY_START) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((bm_linkLossSlot >> i) & 1) + { + lman.linkRecoveryTimer.active |= (1 << i); + lman.linkRecoveryTimer.count[i] = lman.linkRecoveryTimer.count_max; + } + } + rfu_LMAN_occureCallback(LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY, 1); + } + else + { + lman.linkRecovery_start_flag = 0; + rfu_LMAN_disconnect(bm_linkLossSlot); + disconnect_occure_flag = TRUE; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1); + } + } + else + { + rfu_LMAN_disconnect(bm_linkLossSlot); + disconnect_occure_flag = TRUE; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED, 2); + } + rfu_LMAN_managerChangeAgbClockMaster(); + } + if (gRfuLinkStatus->parentChild == MODE_PARENT) + { + if (bm_linkRecoverySlot) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((lman.linkRecoveryTimer.active >> i) & 1 && (bm_linkRecoverySlot >> i) & 1) + { + lman.linkRecoveryTimer.count[i] = 0; + } + } + lman.linkRecoveryTimer.active &= ~bm_linkRecoverySlot; + lman.param[0] = bm_linkRecoverySlot; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_SUCCESSED, 1); + } + if (lman.linkRecoveryTimer.active) + { + bm_disconnectSlot = 0; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((lman.linkRecoveryTimer.active >> i) & 1 && lman.linkRecoveryTimer.count[i] && --lman.linkRecoveryTimer.count[i] == 0) + { + lman.linkRecoveryTimer.active &= ~(1 << i); + bm_disconnectSlot |= (1 << i); + } + } + if (bm_disconnectSlot) + { + rfu_LMAN_disconnect(bm_disconnectSlot); + disconnect_occure_flag = TRUE; + lman.param[0] = bm_disconnectSlot; + rfu_LMAN_occureCallback(LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED, 1); + } + } + if (!lman.linkRecoveryTimer.active) + { + lman.linkRecovery_start_flag = 0; + } + } + return disconnect_occure_flag; +} + +void rfu_LMAN_syncVBlank(void) +{ + if (rfu_syncVBlank()) + { + rfu_LMAN_occureCallback(LMAN_MSG_WATCH_DOG_TIMER_ERROR, 0); + rfu_LMAN_managerChangeAgbClockMaster(); + } +} + +void rfu_LMAN_manager_entity(u32 rand) +{ + u8 msg; + + if (lman.LMAN_callback == NULL && lman.state != LMAN_STATE_READY) + { + lman.state = LMAN_STATE_READY; + return; + } + if (lman.pcswitch_flag) + { + rfu_LMAN_settingPCSWITCH(rand); + } + while (1) + { + if (lman.state != LMAN_STATE_READY) + { + rfu_waitREQComplete(); + lman.active = 1; + switch (lman.state) + { + case LMAN_FORCED_STOP_AND_RFU_RESET: + if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID) + { + msg=LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET; + } + else + { + msg=LMAN_MSG_RFU_FATAL_ERROR; + } + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_occureCallback(msg, 0); + break; + case LMAN_STATE_SOFT_RESET_AND_CHECK_ID: + if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID) + { + lman.state = lman.next_state; + lman.next_state = LMAN_STATE_CONFIG_SYSTEM; + } + else + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_occureCallback(LMAN_MSG_RFU_FATAL_ERROR, 0); + } + break; + case LMAN_STATE_RESET: + rfu_REQ_reset(); + break; + case LMAN_STATE_CONFIG_SYSTEM: + rfu_REQ_configSystem(lman.init_param->availSlot_flag, lman.init_param->maxMFrame, lman.init_param->MC_TimerCount); + break; + case LMAN_STATE_CONFIG_GAME_DATA: + rfu_REQ_configGameData(lman.init_param->mboot_flag, lman.init_param->serialNo, (const u8 *)lman.init_param->gameName, lman.init_param->userName); + break; + case LMAN_STATE_START_SEARCH_CHILD: + rfu_REQ_startSearchChild(); + break; + case LMAN_STATE_POLL_SEARCH_CHILD: + rfu_REQ_pollSearchChild(); + break; + case LMAN_STATE_END_SEARCH_CHILD: + rfu_REQ_endSearchChild(); + break; + case LMAN_STATE_WAIT_RECV_CHILD_NAME: + break; + case LMAN_STATE_START_SEARCH_PARENT: + rfu_REQ_startSearchParent(); + break; + case LMAN_STATE_POLL_SEARCH_PARENT: + rfu_REQ_pollSearchParent(); + break; + case LMAN_STATE_END_SEARCH_PARENT: + rfu_REQ_endSearchParent(); + break; + case LMAN_STATE_START_CONNECT_PARENT: + rfu_REQ_startConnectParent(lman.work); + break; + case LMAN_STATE_POLL_CONNECT_PARENT: + rfu_REQ_pollConnectParent(); + break; + case LMAN_STATE_END_CONNECT_PARENT: + rfu_REQ_endConnectParent(); + break; + case LMAN_STATE_SEND_CHILD_NAME: + break; + case LMAN_STATE_START_LINK_RECOVERY: + rfu_REQ_CHILD_startConnectRecovery(gRfuLinkStatus->linkLossSlotFlag); + break; + case LMAN_STATE_POLL_LINK_RECOVERY: + rfu_REQ_CHILD_pollConnectRecovery(); + break; + case LMAN_STATE_END_LINK_RECOVERY: + rfu_REQ_CHILD_endConnectRecovery(); + break; + case LMAN_STATE_MS_CHANGE: + rfu_REQ_changeMasterSlave(); + break; + case LMAN_STATE_WAIT_CLOCK_MASTER: + break; + case LMAN_STATE_STOP_MODE: + rfu_REQ_stopMode(); + break; + case LMAN_STATE_BACK_STATE: + break; + default: + break; + } + rfu_waitREQComplete(); + lman.active = 0; + } + if (lman.state == LMAN_STATE_END_LINK_RECOVERY || lman.state == LMAN_STATE_MS_CHANGE) + ; + else + break; + } + if (gRfuLinkStatus->parentChild == MODE_PARENT) + { + if (rfu_LMAN_linkWatcher(0)) + return; + } + rfu_LMAN_PARENT_checkRecvChildName(); + rfu_LMAN_CHILD_checkSendChildName(); + rfu_LMAN_CHILD_linkRecoveryProcess(); + rfu_LMAN_checkNICommunicateStatus(); +} + +static void rfu_LMAN_settingPCSWITCH(u32 rand) +{ + if (lman.pcswitch_flag == PCSWITCH_3RD_SC_START) + { + lman.parent_child = MODE_PARENT; + lman.state = LMAN_STATE_START_SEARCH_CHILD; + lman.connect_period = lman.pcswitch_period_bak; + if (lman.connect_period) + { + lman.pcswitch_flag = PCSWITCH_3RD_SC; + } + else + { + lman.pcswitch_flag = PCSWITCH_1ST_SC_START; + } + } + if (lman.pcswitch_flag == PCSWITCH_1ST_SC_START) + { + lman.parent_child = MODE_PARENT; + lman.state = LMAN_STATE_START_SEARCH_CHILD; + lman.connect_period = rand % 140; + lman.pcswitch_period_bak = 140 - lman.connect_period; + if (lman.connect_period) + { + lman.pcswitch_flag = PCSWITCH_1ST_SC; + } + else + { + lman.pcswitch_flag = PCSWITCH_2ND_SP_START; + } + } + if (lman.pcswitch_flag == PCSWITCH_2ND_SP_START) + { + lman.parent_child = MODE_CHILD; + lman.connect_period = PCSWITCH_SP_PERIOD; + lman.pcswitch_flag = PCSWITCH_2ND_SP; + lman.state = LMAN_STATE_START_SEARCH_PARENT; + } +} + +static void rfu_LMAN_REQ_callback(u16 reqCommandId, u16 reqResult) +{ + u8 status; + u8 *stwiRecvBuffer; + u8 i; + + if (lman.active != 0) + { + lman.active = 0; + switch (reqCommandId) + { + case ID_RESET_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state; + lman.next_state = LMAN_STATE_CONFIG_GAME_DATA; + } + break; + case ID_SYSTEM_CONFIG_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state; + lman.next_state = LMAN_STATE_READY; + } + break; + case ID_GAME_CONFIG_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_occureCallback(LMAN_MSG_INITIALIZE_COMPLETED, 0); + } + break; + case ID_SC_START_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state = LMAN_STATE_POLL_SEARCH_CHILD; + } + break; + case ID_SC_POLL_REQ: + if (lman.connect_period && --lman.connect_period == 0) + { + lman.state = LMAN_STATE_END_SEARCH_CHILD; + lman.next_state = LMAN_STATE_WAIT_RECV_CHILD_NAME; + } + break; + case ID_SC_END_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state; + lman.next_state = LMAN_STATE_READY; + if (lman.pcswitch_flag == 0) + { + rfu_LMAN_occureCallback(LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED, 0); + } + } + break; + case ID_SP_START_REQ: + if (reqResult == 0) + { + if (lman.fastSearchParent_flag == FSP_ON) + { + if (lman.connect_period > 1) + { + lman.connect_period--; + } + } + lman.state = lman.next_state = LMAN_STATE_POLL_SEARCH_PARENT; + } + break; + case ID_SP_POLL_REQ: + if (reqResult == 0) + { + status = rfu_LMAN_CHILD_checkEnableParentCandidate(); + lman.param[0] = status; + if (status) + { + rfu_LMAN_occureCallback(LMAN_MSG_PARENT_FOUND, 1); + } + if (lman.fastSearchParent_flag && lman.connect_period != 1 && gRfuLinkStatus->findParentCount == RFU_CHILD_MAX) + { + rfu_REQ_endSearchParent(); + rfu_waitREQComplete(); + lman.state = LMAN_STATE_START_SEARCH_PARENT; + lman.fastSearchParent_flag = FSP_ON; + } + } + if (lman.connect_period && --lman.connect_period == 0) + { + lman.state = LMAN_STATE_END_SEARCH_PARENT; + lman.next_state = LMAN_STATE_READY; + } + break; + case ID_SP_END_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state; + if (lman.pcswitch_flag == 0) + { + if (lman.state == LMAN_STATE_READY) + { + rfu_LMAN_occureCallback(LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED, 0); + } + } + else if (lman.pcswitch_flag != PCSWITCH_CP) + { + lman.state = LMAN_STATE_START_SEARCH_CHILD; + lman.pcswitch_flag = PCSWITCH_3RD_SC_START; + } + } + break; + case ID_CP_START_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state = LMAN_STATE_POLL_CONNECT_PARENT; + } + break; + case ID_CP_POLL_REQ: + if (reqResult == 0 && !rfu_getConnectParentStatus(&status, &lman.child_slot) && !status) + { + lman.state = LMAN_STATE_END_CONNECT_PARENT; + } + if (lman.connect_period && --lman.connect_period == 0) + { + lman.state = LMAN_STATE_END_CONNECT_PARENT; + } + break; + case ID_CP_END_REQ: + if (reqResult == 0 && !rfu_getConnectParentStatus(&status, &lman.child_slot)) + { + if (!status) + { + lman.state = LMAN_STATE_MS_CHANGE; + lman.next_state = LMAN_STATE_SEND_CHILD_NAME; + lman.work = 0x22; + lman.param[0] = lman.child_slot; + } + else + { + lman.state = lman.next_state = LMAN_STATE_READY; + lman.work = 0x23; + lman.param[0] = status; + if (lman.pcswitch_flag) + { + lman.pcswitch_flag = PCSWITCH_2ND_SP_START; + lman.state = LMAN_STATE_START_SEARCH_PARENT; + } + } + rfu_LMAN_occureCallback(lman.work, 0x01); + lman.work = 0; + } + break; + case ID_CPR_START_REQ: + if (reqResult == 0) + { + lman.param[0] = gRfuLinkStatus->linkLossSlotFlag; + lman.state = lman.next_state = LMAN_STATE_POLL_LINK_RECOVERY; + for (lman.child_slot = 0; lman.child_slot < RFU_CHILD_MAX; lman.child_slot++) + { + if ((gRfuLinkStatus->linkLossSlotFlag >> lman.child_slot) & 1) + { + break; + } + } + } + break; + case ID_CPR_POLL_REQ: + if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&status) && status < 2) + { + lman.state = LMAN_STATE_END_LINK_RECOVERY; + } + if (lman.linkRecoveryTimer.count[lman.child_slot] && --lman.linkRecoveryTimer.count[lman.child_slot] == 0) + { + lman.state = LMAN_STATE_END_LINK_RECOVERY; + } + break; + case ID_CPR_END_REQ: + if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&status)) + { + if (!status) + { + lman.state = LMAN_STATE_MS_CHANGE; + lman.next_state = LMAN_STATE_BACK_STATE; + lman.work = 0x32; + } + else + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_disconnect(gRfuLinkStatus->linkLossSlotFlag); + lman.work = 0x33; + } + lman.linkRecoveryTimer.count[lman.child_slot] = 0; + lman.linkRecoveryTimer.active = 0; + lman.linkRecovery_start_flag = 0; + rfu_LMAN_occureCallback(lman.work, 0x01); + lman.work = 0; + } + break; + case ID_MS_CHANGE_REQ: + if (reqResult == 0) + { + if (lman.next_state == LMAN_STATE_BACK_STATE) + { + lman.state = lman.state_bak[0]; + lman.next_state = lman.state_bak[1]; + lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_ON; + rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_SLAVE, 0); + } + else if (lman.next_state == LMAN_STATE_SEND_CHILD_NAME) + { + lman.state = lman.next_state; + lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_ON; + rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_SLAVE, 0); + lman.nameAcceptTimer.active |= 1 << lman.child_slot; + lman.nameAcceptTimer.count[lman.child_slot] = lman.nameAcceptTimer.count_max; + rfu_clearSlot(TYPE_NI_SEND, lman.child_slot); + status = rfu_NI_CHILD_setSendGameName(lman.child_slot, 0x0e); + if (status) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_managerChangeAgbClockMaster(); + rfu_LMAN_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); + lman.param[0] = status; + rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED, 1); + } + } + } + break; + case ID_STOP_MODE_REQ: + if (reqResult == 0) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_occureCallback(LMAN_MSG_RFU_POWER_DOWN, 0); + } + break; + } + lman.active = 1; + } + else if (reqResult == 3 && lman.msc_exe_flag && (reqCommandId == ID_DATA_TX_REQ || reqCommandId == ID_DATA_RX_REQ || reqCommandId == ID_MS_CHANGE_REQ)) + { + rfu_REQ_RFUStatus(); + rfu_waitREQComplete(); + rfu_getRFUStatus(&status); + if (status == 0 && gRfuLinkStatus->parentChild == MODE_CHILD) + { + stwiRecvBuffer = rfu_getSTWIRecvBuffer() + 4; + *stwiRecvBuffer++ = gRfuLinkStatus->connSlotFlag; + *stwiRecvBuffer = REASON_LINK_LOSS; + rfu_LMAN_linkWatcher(ID_DISCONNECTED_AND_CHANGE_REQ); + reqResult = 0; + } + } + switch (reqCommandId) + { + case ID_DISCONNECT_REQ: + if (reqResult == 0) + { + lman.param[0] = *(rfu_getSTWIRecvBuffer() + 8); + rfu_LMAN_reflectCommunicationStatus(lman.param[0]); + if (lman.linkRecoveryTimer.active) + { + lman.linkRecoveryTimer.active &= ~lman.param[0]; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((lman.param[0] >> i) & 1) + { + lman.linkRecoveryTimer.count[i] = 0; + } + } + if (lman.parent_child == MODE_CHILD) + { + lman.state = lman.next_state = LMAN_STATE_READY; + } + } + status = lman.acceptSlot_flag & lman.param[0]; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((status >> i) & 1 && lman.acceptCount) + { + lman.acceptCount--; + } + } + lman.acceptSlot_flag &= ~lman.param[0]; + if (lman.pcswitch_flag) + { + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) + { + if (lman.pcswitch_flag == PCSWITCH_SC_LOCK) + { + lman.connect_period = lman.pcswitch_period_bak; + lman.pcswitch_flag = PCSWITCH_3RD_SC; + lman.state = LMAN_STATE_POLL_SEARCH_CHILD; + } + else if (lman.state != LMAN_STATE_POLL_SEARCH_CHILD && lman.state != LMAN_STATE_END_SEARCH_CHILD) + { + lman.pcswitch_flag = PCSWITCH_1ST_SC_START; + lman.state = LMAN_STATE_START_SEARCH_CHILD; + } + } + } + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) + { + if (lman.state == LMAN_STATE_READY) + { + lman.parent_child = MODE_NEUTRAL; + } + } + if (lman.active == 0) + { + rfu_LMAN_occureCallback(LMAN_MSG_LINK_DISCONNECTED_BY_USER, 1); + } + } + break; + case ID_DATA_RX_REQ: + rfu_LMAN_CHILD_checkSendChildName2(); + if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) + { + rfu_LMAN_occureCallback(LMAN_MSG_RECV_DATA_REQ_COMPLETED, 0); + } + break; + case ID_RESET_REQ: + case ID_STOP_MODE_REQ: + if (reqResult == 0) + { + lman.reserveDisconnectSlot_flag = 0; + lman.acceptCount = 0; + lman.acceptSlot_flag = 0;; + lman.parent_child = MODE_NEUTRAL; + rfu_LMAN_managerChangeAgbClockMaster(); + if (reqCommandId == ID_STOP_MODE_REQ) + { + rfu_LMAN_endManager(); + } + } + break; + } + if (reqResult != 0) + { + if (reqCommandId == ID_SP_START_REQ && reqResult != 0 && lman.pcswitch_flag == PCSWITCH_2ND_SP) + { + gRfuLinkStatus->parentChild = MODE_PARENT; + gRfuLinkStatus->connSlotFlag = 0xF; + rfu_LMAN_disconnect(15); + rfu_waitREQComplete(); + return; + } + else + { + lman.param[0] = reqCommandId; + lman.param[1] = reqResult; + if (lman.active) + { + lman.state = lman.next_state = LMAN_STATE_READY; + } + rfu_LMAN_occureCallback(LMAN_MSG_REQ_API_ERROR, 2); + rfu_LMAN_managerChangeAgbClockMaster(); + } + } + if (reqCommandId == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ) + { + rfu_LMAN_occureCallback(LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA, 0); + rfu_LMAN_managerChangeAgbClockMaster(); + } +} + +static void rfu_LMAN_MSC_callback(u16 reqCommandId) +{ + u8 active_bak; + u8 thisAck_flag; + + active_bak = lman.active; + lman.active = 0; + lman.msc_exe_flag = 1; + if (gRfuLinkStatus->parentChild == MODE_CHILD) + { + rfu_LMAN_linkWatcher(reqCommandId); + if (lman.childClockSlave_flag != RFU_CHILD_CLOCK_SLAVE_ON) + { + rfu_LMAN_managerChangeAgbClockMaster(); + lman.msc_exe_flag = 0; + lman.active = active_bak; + return; + } + } + else + { + if (!rfu_UNI_PARENT_getDRAC_ACK(&thisAck_flag)) + { + lman.parentAck_flag |= thisAck_flag; + } + } + if (lman.MSC_callback != NULL) + { + lman.MSC_callback(reqCommandId); + rfu_waitREQComplete(); + if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF_REQ) + { + rfu_LMAN_managerChangeAgbClockMaster(); + } + } + lman.msc_exe_flag = 0; + lman.active = active_bak; +} + +static void rfu_LMAN_PARENT_checkRecvChildName(void) +{ + u8 newSlot; + u8 newAcceptSlot; + u8 i; + u8 flags; + u8 tgtSlot; + const u16 *ptr; + + if (lman.state == LMAN_STATE_START_SEARCH_CHILD || lman.state == LMAN_STATE_POLL_SEARCH_CHILD || lman.state == LMAN_STATE_END_SEARCH_CHILD || lman.state == LMAN_STATE_WAIT_RECV_CHILD_NAME) + { + newSlot = ((gRfuLinkStatus->connSlotFlag ^ lman.connectSlot_flag_old) & gRfuLinkStatus->connSlotFlag) & ~gRfuLinkStatus->getNameFlag; + lman.connectSlot_flag_old = gRfuLinkStatus->connSlotFlag; + if (newSlot) + { + lman.param[0] = newSlot; + rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_DETECTED, 1); + } + newAcceptSlot = 0x00; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + tgtSlot = 1 << i; + flags = 0x00; + if (newSlot & tgtSlot) + { + lman.nameAcceptTimer.count[i] = lman.nameAcceptTimer.count_max; + lman.nameAcceptTimer.active |= tgtSlot; + } + else if (lman.nameAcceptTimer.active & tgtSlot) + { + if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS) + { + if (gRfuSlotStatusNI[i]->recv.dataType == 1) + { + flags = RN_NAME_TIMER_CLEAR; + for (ptr = lman.acceptable_serialNo_list; *ptr != 0xFFFF; ptr++) + { + if (gRfuLinkStatus->partner[i].serialNo == *ptr) + { + lman.acceptSlot_flag |= tgtSlot; + lman.acceptCount++; + newAcceptSlot |= tgtSlot; + flags |= RN_ACCEPT; + break; + } + } + if (!(flags & RN_ACCEPT)) + { + flags |= RN_DISCONNECT; + } + } + } + else if (--lman.nameAcceptTimer.count[i] == 0) + { + flags = RN_NAME_TIMER_CLEAR | RN_DISCONNECT; + } + if (flags & RN_NAME_TIMER_CLEAR) + { + lman.nameAcceptTimer.active &= ~tgtSlot; + lman.nameAcceptTimer.count[i] = 0; + rfu_clearSlot(TYPE_NI_RECV, i); + } + if (flags & RN_DISCONNECT) + { + lman.reserveDisconnectSlot_flag |= tgtSlot; + } + } + } + if (newAcceptSlot) + { + lman.param[0] = newAcceptSlot; + rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED, 1); + } + if (lman.reserveDisconnectSlot_flag) + { + flags = 1; + if (gRfuLinkStatus->sendSlotUNIFlag) + { + if (((lman.parentAck_flag & lman.acceptSlot_flag) != lman.acceptSlot_flag)) + { + flags = 0; + } + } + if (flags) + { + rfu_LMAN_disconnect(lman.reserveDisconnectSlot_flag); + lman.param[0] = lman.reserveDisconnectSlot_flag; + lman.reserveDisconnectSlot_flag = 0; + rfu_LMAN_occureCallback(LMAN_MSG_NEW_CHILD_CONNECT_REJECTED, 1); + } + } + if (lman.nameAcceptTimer.active == 0 && lman.state == LMAN_STATE_WAIT_RECV_CHILD_NAME) + { + if (lman.pcswitch_flag == 0) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_occureCallback(LMAN_MSG_END_WAIT_CHILD_NAME, 0); + } + else + { + if (lman.pcswitch_flag == PCSWITCH_1ST_SC) + { + lman.pcswitch_flag = PCSWITCH_2ND_SP_START; + lman.state = LMAN_STATE_START_SEARCH_PARENT; + } + else + { + lman.pcswitch_flag = PCSWITCH_1ST_SC_START; + lman.state = LMAN_STATE_START_SEARCH_CHILD; + } + if (lman.acceptSlot_flag) + { + lman.connect_period = 0; + lman.pcswitch_flag = PCSWITCH_SC_LOCK; + lman.state = LMAN_STATE_START_SEARCH_CHILD; + } + } + } + } +} + +static void rfu_LMAN_CHILD_checkSendChildName(void) +{ + u16 imeBak = REG_IME; + REG_IME = 0; + if (lman.state == LMAN_STATE_SEND_CHILD_NAME) + { + if (--lman.nameAcceptTimer.count[lman.child_slot] == 0 || gRfuSlotStatusNI[lman.child_slot]->send.state == SLOT_STATE_SEND_FAILED) + { + rfu_LMAN_requestChangeAgbClockMaster(); + lman.state = LMAN_STATE_WAIT_CHANGE_CLOCK_MASTER; + rfu_clearSlot(TYPE_NI_SEND, lman.child_slot); + lman.nameAcceptTimer.active &= ~(1 << lman.child_slot); + lman.nameAcceptTimer.count[lman.child_slot] = 0; + } + } + REG_IME = imeBak; + if (lman.state == LMAN_STATE_WAIT_CHANGE_CLOCK_MASTER) + { + if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON) + { + rfu_LMAN_requestChangeAgbClockMaster(); + } + if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_LMAN_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); + lman.param[0] = 0; + rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED, 1); + } + } +} + +static void rfu_LMAN_CHILD_checkSendChildName2(void) +{ + if (lman.state == LMAN_STATE_SEND_CHILD_NAME && gRfuSlotStatusNI[lman.child_slot]->send.state == SLOT_STATE_SEND_SUCCESS) + { + lman.state = lman.next_state = LMAN_STATE_READY; + rfu_clearSlot(TYPE_NI_SEND, lman.child_slot); + lman.nameAcceptTimer.active &= ~(1 << lman.child_slot); + lman.nameAcceptTimer.count[lman.child_slot] = 0; + rfu_LMAN_occureCallback(LMAN_MSG_CHILD_NAME_SEND_COMPLETED, 0); + } +} + +static void rfu_LMAN_CHILD_linkRecoveryProcess(void) +{ + if (lman.parent_child == MODE_CHILD && lman.linkRecovery_start_flag == LINK_RECOVERY_START) + { + lman.state_bak[0] = lman.state; + lman.state_bak[1] = lman.next_state; + lman.state = LMAN_STATE_START_LINK_RECOVERY; + lman.next_state = LMAN_STATE_POLL_LINK_RECOVERY; + lman.linkRecovery_start_flag = LINK_RECOVERY_EXE; + } +} + +static u8 rfu_LMAN_CHILD_checkEnableParentCandidate(void) +{ + u8 i; + u16 *serialNo; + u8 flags = 0x00; + + for (i = 0; i < gRfuLinkStatus->findParentCount; i++) + { + for (serialNo = lman.acceptable_serialNo_list; *serialNo != 0xFFFF; serialNo++) + { + if (gRfuLinkStatus->partner[i].serialNo == *serialNo) + { + flags |= (1 << i); + } + } + } + return flags; +} + +static void rfu_LMAN_occureCallback(u8 msg, u8 param_count) +{ + if (lman.LMAN_callback != NULL) + { + lman.LMAN_callback(msg, param_count); + } + lman.param[0] = lman.param[1] = 0; +} + +static void rfu_LMAN_disconnect(u8 bm_disconnectedSlot) +{ + u8 active_bak = lman.active; + lman.active = 1; + rfu_REQ_disconnect(bm_disconnectedSlot); + rfu_waitREQComplete(); + lman.active = active_bak; +} + +static void rfu_LMAN_reflectCommunicationStatus(u8 bm_disconnectedSlot) +{ + u8 i; + + if (gRfuLinkStatus->sendSlotNIFlag) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->send.bmSlot & bm_disconnectedSlot) + { + rfu_changeSendTarget(TYPE_NI, i, gRfuSlotStatusNI[i]->send.bmSlot & ~bm_disconnectedSlot); + } + } + } + if (gRfuLinkStatus->recvSlotNIFlag) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.bmSlot & bm_disconnectedSlot) + { + rfu_NI_stopReceivingData(i); + } + } + } + if (gRfuLinkStatus->sendSlotUNIFlag) + { + gRfuLinkStatus->sendSlotUNIFlag &= ~bm_disconnectedSlot; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI && bm_disconnectedSlot & gRfuSlotStatusUNI[i]->send.bmSlot) + { + gRfuSlotStatusUNI[i]->send.bmSlot &= ~bm_disconnectedSlot; + } + } + } +} + +static void rfu_LMAN_checkNICommunicateStatus(void) +{ + u8 i; + u8 j; + u8 flags; + + if (lman.NI_failCounter_limit) + { + if (gRfuLinkStatus->sendSlotNIFlag) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG) + { + flags = 0; + for (j = 0; j < RFU_CHILD_MAX; j++) + { + if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > lman.NI_failCounter_limit) + { + flags |= (1 << j); + } + if (flags) + { + rfu_changeSendTarget(TYPE_NI, i, flags ^ gRfuSlotStatusNI[i]->send.bmSlot); + } + } + } + } + } + if (gRfuLinkStatus->recvSlotNIFlag) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.failCounter > lman.NI_failCounter_limit) + { + rfu_NI_stopReceivingData(i); + } + } + } + } +} + +void rfu_LMAN_setMSCCallback(void (*MSC_callback_p)(u16)) +{ + lman.MSC_callback = MSC_callback_p; + rfu_setMSCCallback(rfu_LMAN_MSC_callback); +} + +static void rfu_LMAN_setLMANCallback(void (*func)(u8, u8)) +{ + lman.LMAN_callback = func; +} + +u8 rfu_LMAN_setLinkRecovery(u8 enable_flag, u16 recovery_period) +{ + u16 imeBak; + if (lman.linkRecovery_enable && enable_flag == 0 && lman.linkRecoveryTimer.active) + { + return LMAN_ERROR_NOW_LINK_RECOVERY; + } + imeBak = REG_IME; + REG_IME = 0; + lman.linkRecovery_enable = enable_flag; + lman.linkRecoveryTimer.count_max = recovery_period; + REG_IME = imeBak; + return 0; +} + +static u8 rfu_LMAN_setNIFailCounterLimit(u16 NI_failCounter_limit) +{ + if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag) + { + lman.param[0] = 6; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_NOW_COMMUNICATION; + } + lman.NI_failCounter_limit = NI_failCounter_limit; + return 0; +} + +static u8 rfu_LMAN_setFastSearchParent(u8 enable_flag) +{ + if (lman.state == LMAN_STATE_START_SEARCH_PARENT || lman.state == LMAN_STATE_POLL_SEARCH_PARENT || lman.state == LMAN_STATE_END_SEARCH_PARENT) + { + lman.param[0] = 7; + rfu_LMAN_occureCallback(LMAN_MSG_LMAN_API_ERROR_RETURN, 1); + return LMAN_ERROR_NOW_SEARCH_PARENT; + } + if (enable_flag) + { + lman.fastSearchParent_flag = FSP_ON; + } + else + { + lman.fastSearchParent_flag = 0; + } + return 0; +} + +static void rfu_LMAN_managerChangeAgbClockMaster(void) +{ + if (lman.childClockSlave_flag != RFU_CHILD_CLOCK_SLAVE_OFF) + { + lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_OFF; + rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_MASTER, 0); + } +} + +void rfu_LMAN_requestChangeAgbClockMaster(void) +{ + if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_OFF) + { + rfu_LMAN_occureCallback(LMAN_MSG_CHANGE_AGB_CLOCK_MASTER, 0); + } + else if (lman.childClockSlave_flag == RFU_CHILD_CLOCK_SLAVE_ON) + { + lman.childClockSlave_flag = RFU_CHILD_CLOCK_SLAVE_OFF_REQ; + } +} + +void rfu_LMAN_forceChangeSP(void) +{ + if (lman.pcswitch_flag) + { + switch (lman.state) + { + case LMAN_STATE_START_SEARCH_CHILD: + lman.pcswitch_flag = PCSWITCH_2ND_SP_START; + lman.state = LMAN_STATE_START_SEARCH_PARENT; + break; + case LMAN_STATE_POLL_SEARCH_CHILD: + lman.pcswitch_flag = PCSWITCH_1ST_SC; + lman.connect_period = 1; + break; + case LMAN_STATE_END_SEARCH_CHILD: + case LMAN_STATE_WAIT_RECV_CHILD_NAME: + lman.pcswitch_flag = PCSWITCH_1ST_SC; + break; + case LMAN_STATE_START_SEARCH_PARENT: + case LMAN_STATE_POLL_SEARCH_PARENT: + lman.connect_period = PCSWITCH_SP_PERIOD; + break; + case LMAN_STATE_END_SEARCH_PARENT: + lman.connect_period = PCSWITCH_SP_PERIOD; + lman.state = LMAN_STATE_POLL_SEARCH_PARENT; + break; + } + } +} diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index cb9e04a50..7b0a8aa47 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -831,9 +831,9 @@ void sub_802F6A8(void) if (gBattleTypeFlags & BATTLE_TYPE_LINK) { if (gWirelessCommType == 0) - sub_800AAC0(); + Link_TryStartSend5FFF(); else - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gBattlerControllerFuncs[gActiveBattler] = sub_802F610; } else diff --git a/src/battle_controllers.c b/src/battle_controllers.c index ca2ef0b22..834b9e6b6 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -35,7 +35,7 @@ void HandleLinkBattleSetup(void) if (gBattleTypeFlags & BATTLE_TYPE_LINK) { if (gWirelessCommType) - sub_800B1F4(); + SetWirelessCommType1(); if (!gReceivedRemoteLinkPlayers) OpenLink(); CreateTask(sub_8081A90, 0); @@ -491,7 +491,7 @@ void sub_800DD28(void) if (gReceivedRemoteLinkPlayers && (gBattleTypeFlags & BATTLE_TYPE_20) && (gLinkPlayers[0].linkType == 0x2211)) { - sub_80FBB4C(); + LinkRfu_DestroyIdleTask(); for (i = 0; i < GetLinkPlayerCount(); ++i) { if (GetBlockReceivedStatus() & gBitTable[i]) diff --git a/src/battle_main.c b/src/battle_main.c index 76f373f8f..3f20399f6 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -1152,9 +1152,9 @@ static void CB2_PreInitMultiBattle(void) { ++gBattleCommunication[MULTIUSE_STATE]; if (gWirelessCommType) - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); else - sub_800AAC0(); + Link_TryStartSend5FFF(); } break; case 3: diff --git a/src/digit_obj_util.c b/src/digit_obj_util.c new file mode 100644 index 000000000..af2618615 --- /dev/null +++ b/src/digit_obj_util.c @@ -0,0 +1,449 @@ +#include "global.h" +#include "malloc.h" +#include "decompress.h" +#include "digit_obj_util.h" +#include "main.h" +#include "battle.h" + +struct DigitPrinterAlloc +{ + u32 count; + struct DigitPrinter + { + bool8 isActive; + u8 firstOamId; + u8 strConvMode; + u8 oamCount; + u8 palTagIndex; + u8 size; + u8 shape; + u8 priority; + u8 xDelta; + u8 tilesPerImage; + u16 tileStart; + s16 x; + s16 y; + u16 tileTag; + u16 palTag; + u32 pow10; + s32 lastPrinted; + } *array; +}; + +// this file's functions +static u8 GetFirstOamId(u8 oamCount); +static void CopyWorkToOam(struct DigitPrinter *objWork); +static void DrawNumObjsLeadingZeros(struct DigitPrinter *objWork, s32 num, bool32 sign); +static void DrawNumObjsMinusInFront(struct DigitPrinter *objWork, s32 num, bool32 sign); +static void DrawNumObjsMinusInBack(struct DigitPrinter *objWork, s32 num, bool32 sign); +static bool32 SharesTileWithAnyActive(u32 id); +static bool32 SharesPalWithAnyActive(u32 id); +static u8 GetTilesPerImage(u32 shape, u32 size); + +// ewram +static EWRAM_DATA struct DigitPrinterAlloc *sOamWork = {0}; + +// const rom data +static const u8 sTilesPerImage[4][4] = +{ + [ST_OAM_SQUARE] = { + [ST_OAM_SIZE_0] = 0x01, // SPRITE_SIZE_8x8 + [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_16x16 + [ST_OAM_SIZE_2] = 0x10, // SPRITE_SIZE_32x32 + [ST_OAM_SIZE_3] = 0x40 // SPRITE_SIZE_64x64 + }, + [ST_OAM_H_RECTANGLE] = { + [ST_OAM_SIZE_0] = 0x02, // SPRITE_SIZE_16x8 + [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_32x8 + [ST_OAM_SIZE_2] = 0x08, // SPRITE_SIZE_32x16 + [ST_OAM_SIZE_3] = 0x20 // SPRITE_SIZE_64x32 + }, + [ST_OAM_V_RECTANGLE] = { + [ST_OAM_SIZE_0] = 0x02, // SPRITE_SIZE_8x16 + [ST_OAM_SIZE_1] = 0x04, // SPRITE_SIZE_8x32 + [ST_OAM_SIZE_2] = 0x08, // SPRITE_SIZE_16x32 + [ST_OAM_SIZE_3] = 0x20 // SPRITE_SIZE_32x64 + } +}; + +// code +bool32 DigitObjUtil_Init(u32 count) +{ + u32 i; + + if (sOamWork != NULL) + DigitObjUtil_Teardown(); + + sOamWork = Alloc(sizeof(*sOamWork)); + if (sOamWork == NULL) + return FALSE; + + sOamWork->array = Alloc(sizeof(struct DigitPrinter) * count); + if (sOamWork->array == NULL) + { + Free(sOamWork); + return FALSE; + } + + sOamWork->count = count; + for (i = 0; i < count; i++) + { + sOamWork->array[i].isActive = FALSE; + sOamWork->array[i].firstOamId = 0xFF; + } + + return TRUE; +} + +void DigitObjUtil_Teardown(void) +{ + if (sOamWork != NULL) + { + if (sOamWork->array != NULL) + { + u32 i; + + for (i = 0; i < sOamWork->count; i++) + DigitObjUtil_DeletePrinter(i); + + Free(sOamWork->array); + } + + FREE_AND_SET_NULL(sOamWork); + } +} + +bool32 DigitObjUtil_CreatePrinter(u32 id, s32 num, const struct DigitObjUtilTemplate *template) +{ + u32 i; + + if (sOamWork == NULL) + return FALSE; + if (sOamWork->array[id].isActive) + return FALSE; + + sOamWork->array[id].firstOamId = GetFirstOamId(template->oamCount); + if (sOamWork->array[id].firstOamId == 0xFF) + return FALSE; + + sOamWork->array[id].tileStart = GetSpriteTileStartByTag(template->spriteSheet->tag); + if (sOamWork->array[id].tileStart == 0xFFFF) + { + if (template->spriteSheet->size != 0) + { + sOamWork->array[id].tileStart = LoadSpriteSheet(template->spriteSheet); + } + else + { + struct CompressedSpriteSheet compObjectPic; + + compObjectPic = *(struct CompressedSpriteSheet*)(template->spriteSheet); + compObjectPic.size = GetDecompressedDataSize(template->spriteSheet->data); + sOamWork->array[id].tileStart = LoadCompressedSpriteSheet(&compObjectPic); + } + + if (sOamWork->array[id].tileStart == 0xFFFF) + return FALSE; + } + + sOamWork->array[id].palTagIndex = IndexOfSpritePaletteTag(template->spritePal->tag); + if (sOamWork->array[id].palTagIndex == 0xFF) + sOamWork->array[id].palTagIndex = LoadSpritePalette(template->spritePal); + + sOamWork->array[id].strConvMode = template->strConvMode; + sOamWork->array[id].oamCount = template->oamCount; + sOamWork->array[id].x = template->x; + sOamWork->array[id].y = template->y; + sOamWork->array[id].shape = template->shape; + sOamWork->array[id].size = template->size; + sOamWork->array[id].priority = template->priority; + sOamWork->array[id].xDelta = template->xDelta; + sOamWork->array[id].tilesPerImage = GetTilesPerImage(template->shape, template->size); + sOamWork->array[id].tileTag = template->spriteSheet->tag; + sOamWork->array[id].palTag = template->spritePal->tag; + sOamWork->array[id].isActive = TRUE; + + // Decimal left shift + sOamWork->array[id].pow10 = 1; + for (i = 1; i < template->oamCount; i++) + sOamWork->array[id].pow10 *= 10; + + CopyWorkToOam(&sOamWork->array[id]); + DigitObjUtil_PrintNumOn(id, num); + + return TRUE; +} + +static void CopyWorkToOam(struct DigitPrinter *objWork) +{ + u32 i; + u32 oamId = objWork->firstOamId; + u32 x = objWork->x; + u32 oamCount = objWork->oamCount + 1; + + CpuFill16(0, &gMain.oamBuffer[oamId], sizeof(struct OamData) * oamCount); + for (i = 0, oamId = objWork->firstOamId; i < oamCount; i++, oamId++) + { + gMain.oamBuffer[oamId].y = objWork->y; + gMain.oamBuffer[oamId].x = x; + gMain.oamBuffer[oamId].shape = objWork->shape; + gMain.oamBuffer[oamId].size = objWork->size; + gMain.oamBuffer[oamId].tileNum = objWork->tileStart; + gMain.oamBuffer[oamId].priority = objWork->priority; + gMain.oamBuffer[oamId].paletteNum = objWork->palTagIndex; + + x += objWork->xDelta; + } + + oamId--; + gMain.oamBuffer[oamId].x = objWork->x - objWork->xDelta; + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + gMain.oamBuffer[oamId].tileNum = objWork->tileStart + (objWork->tilesPerImage * 10); +} + +void DigitObjUtil_PrintNumOn(u32 id, s32 num) +{ + bool32 sign; + + if (sOamWork == NULL) + return; + if (!sOamWork->array[id].isActive) + return; + + sOamWork->array[id].lastPrinted = num; + if (num < 0) + { + sign = TRUE; + num *= -1; + } + else + { + sign = FALSE; + } + + switch (sOamWork->array[id].strConvMode) + { + case 0: + default: + DrawNumObjsLeadingZeros(&sOamWork->array[id], num, sign); + break; + case 1: + DrawNumObjsMinusInFront(&sOamWork->array[id], num, sign); + break; + case 2: + DrawNumObjsMinusInBack(&sOamWork->array[id], num, sign); + break; + } +} + +static void DrawNumObjsLeadingZeros(struct DigitPrinter *objWork, s32 num, bool32 sign) +{ + u32 pow10 = objWork->pow10; + u32 oamId = objWork->firstOamId; + + while (pow10 != 0) + { + u32 digit = num / pow10; + num -= (digit * pow10); + pow10 /= 10; + + gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart; + oamId++; + } + + if (sign) + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + else + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; +} + +static void DrawNumObjsMinusInFront(struct DigitPrinter *objWork, s32 num, bool32 sign) +{ + u32 pow10 = objWork->pow10; + static int oamId; + static int curDigit; + static int firstDigit; + + oamId = objWork->firstOamId; + curDigit = 0; + firstDigit = -1; + + while (pow10 != 0) + { + u32 digit = num / pow10; + num -= (digit * pow10); + pow10 /= 10; + + if (digit != 0 || firstDigit != -1 || pow10 == 0) + { + gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart; + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + + if (firstDigit == -1) + firstDigit = curDigit; + } + else + { + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + } + + oamId++; + curDigit++; + } + + if (sign) + { + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + gMain.oamBuffer[oamId].x = objWork->x + ((firstDigit - 1) * objWork->xDelta); + } + else + { + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + } +} + +static void DrawNumObjsMinusInBack(struct DigitPrinter *objWork, s32 num, bool32 sign) +{ + u32 pow10 = objWork->pow10; + u32 oamId = objWork->firstOamId; + u32 printingDigits = 0; + s32 nsprites = 0; + + while (pow10 != 0) + { + u32 digit = num / pow10; + num -= (digit * pow10); + pow10 /= 10; + + if (digit != 0 || printingDigits != 0 || pow10 == 0) + { + printingDigits = 1; + gMain.oamBuffer[oamId].tileNum = (digit * objWork->tilesPerImage) + objWork->tileStart; + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + + oamId++; + nsprites++; + } + } + + while (nsprites < objWork->oamCount) + { + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + oamId++; + nsprites++; + } + + if (sign) + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + else + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; +} + +void DigitObjUtil_DeletePrinter(u32 id) +{ + s32 oamId, oamCount, i; + + if (sOamWork == NULL) + return; + if (!sOamWork->array[id].isActive) + return; + + oamCount = sOamWork->array[id].oamCount + 1; + oamId = sOamWork->array[id].firstOamId; + + for (i = 0; i < oamCount; i++, oamId++) + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + + if (!SharesTileWithAnyActive(id)) + FreeSpriteTilesByTag(sOamWork->array[id].tileTag); + if (!SharesPalWithAnyActive(id)) + FreeSpritePaletteByTag(sOamWork->array[id].palTag); + + sOamWork->array[id].isActive = FALSE; +} + +void DigitObjUtil_HideOrShow(u32 id, bool32 hide) +{ + s32 oamId, oamCount, i; + + if (sOamWork == NULL) + return; + if (!sOamWork->array[id].isActive) + return; + + oamCount = sOamWork->array[id].oamCount + 1; + oamId = sOamWork->array[id].firstOamId; + if (hide) + { + for (i = 0; i < oamCount; i++, oamId++) + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_ERASE; + } + else + { + for (i = 0; i < oamCount; i++, oamId++) + gMain.oamBuffer[oamId].affineMode = ST_OAM_AFFINE_OFF; + + DigitObjUtil_PrintNumOn(id, sOamWork->array[id].lastPrinted); + } +} + +static u8 GetFirstOamId(u8 oamCount) +{ + u32 i; + u16 firstOamId = 64; + + for (i = 0; i < sOamWork->count; i++) + { + if (!sOamWork->array[i].isActive) + { + if (sOamWork->array[i].firstOamId != 0xFF && sOamWork->array[i].oamCount <= oamCount) + return sOamWork->array[i].firstOamId; + } + else + { + firstOamId += 1 + sOamWork->array[i].oamCount; + } + } + + if (firstOamId + oamCount + 1 > 128) + return 0xFF; + else + return firstOamId; +} + +static bool32 SharesTileWithAnyActive(u32 id) +{ + u32 i; + + for (i = 0; i < sOamWork->count; i++) + { + if (sOamWork->array[i].isActive && i != id + && sOamWork->array[i].tileTag == sOamWork->array[id].tileTag) + { + return TRUE; + } + } + + return FALSE; +} + +static bool32 SharesPalWithAnyActive(u32 id) +{ + u32 i; + + for (i = 0; i < sOamWork->count; i++) + { + if (sOamWork->array[i].isActive && i != id + && sOamWork->array[i].palTag == sOamWork->array[id].palTag) + { + return TRUE; + } + } + + return FALSE; +} + +static u8 GetTilesPerImage(u32 shape, u32 size) +{ + return sTilesPerImage[shape][size]; +} diff --git a/src/dodrio_berry_picking_2.c b/src/dodrio_berry_picking_2.c index fc6aa14c6..4260c6f2f 100644 --- a/src/dodrio_berry_picking_2.c +++ b/src/dodrio_berry_picking_2.c @@ -7,7 +7,7 @@ void sub_815A5BC(s32 a0) struct Padded_U8 data[2]; data[0].value = 1; data[1].value = a0; - sub_80F9E2C(data); + RfuPrepareSend0x2f00(data); } u8 sub_815A5E8(s32 a0) diff --git a/src/dynamic_placeholder_text_util.c b/src/dynamic_placeholder_text_util.c index 6909fea30..a2622bf02 100644 --- a/src/dynamic_placeholder_text_util.c +++ b/src/dynamic_placeholder_text_util.c @@ -2,16 +2,89 @@ #include "text.h" #include "dynamic_placeholder_text_util.h" #include "string_util.h" +#include "constants/object_events.h" static EWRAM_DATA const u8 *sStringPointers[8] = {0}; static const u8 sTextColorTable[] = { - 0, 0, 0, 16, 17, 17, 17, 16, 16, 0, 0, 17, 1, 0, 17, 16, - 0, 16, 16, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, - 17, 1, 0, 0, 0, 16, 17, 0, 16, 16, 16, 0, 1, 0, 51, 51, - 51, 51, 51, 51, 51, 51, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, - 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 50, + // [LOW_NYBBLE / 2] = 0xXY, // HIGH_NYBBLE + [OBJECT_EVENT_GFX_RED_NORMAL / 2] = 0x00, // OBJECT_EVENT_GFX_RED_BIKE + [OBJECT_EVENT_GFX_RED_RUN / 2] = 0x00, // OBJECT_EVENT_GFX_RED_ITEM + [OBJECT_EVENT_GFX_RED_FISH / 2] = 0x00, // OBJECT_EVENT_GFX_RED_ITEM_COPY + [OBJECT_EVENT_GFX_RED_VS_SEEKER / 2] = 0x10, // OBJECT_EVENT_GFX_GREEN_NORMAL + [OBJECT_EVENT_GFX_GREEN_BIKE / 2] = 0x11, // OBJECT_EVENT_GFX_GREEN_RUN + [OBJECT_EVENT_GFX_GREEN_ITEM / 2] = 0x11, // OBJECT_EVENT_GFX_GREEN_FISH + [OBJECT_EVENT_GFX_GREEN_ITEM_COPY / 2] = 0x11, // OBJECT_EVENT_GFX_GREEN_VS_SEEKER + [OBJECT_EVENT_GFX_RS_BRENDAN / 2] = 0x10, // OBJECT_EVENT_GFX_RS_MAY + [OBJECT_EVENT_GFX_LITTLE_BOY / 2] = 0x10, // OBJECT_EVENT_GFX_LITTLE_GIRL + [OBJECT_EVENT_GFX_YOUNGSTER / 2] = 0x00, // OBJECT_EVENT_GFX_BOY + [OBJECT_EVENT_GFX_BUG_CATCHER / 2] = 0x00, // OBJECT_EVENT_GFX_SITTING_BOY + [OBJECT_EVENT_GFX_LASS / 2] = 0x11, // OBJECT_EVENT_GFX_WOMAN_1 + [OBJECT_EVENT_GFX_BATTLE_GIRL / 2] = 0x01, // OBJECT_EVENT_GFX_MAN + [OBJECT_EVENT_GFX_ROCKER / 2] = 0x00, // OBJECT_EVENT_GFX_FAT_MAN + [OBJECT_EVENT_GFX_WOMAN_2 / 2] = 0x11, // OBJECT_EVENT_GFX_BEAUTY + [OBJECT_EVENT_GFX_BALDING_MAN / 2] = 0x10, // OBJECT_EVENT_GFX_WOMAN_3 + [OBJECT_EVENT_GFX_OLD_MAN_1 / 2] = 0x00, // OBJECT_EVENT_GFX_OLD_MAN_2 + [OBJECT_EVENT_GFX_OLD_MAN_LYING_DOWN / 2] = 0x10, // OBJECT_EVENT_GFX_OLD_WOMAN + [OBJECT_EVENT_GFX_TUBER_M_1 / 2] = 0x10, // OBJECT_EVENT_GFX_TUBER_F + [OBJECT_EVENT_GFX_TUBER_M_2 / 2] = 0x00, // OBJECT_EVENT_GFX_CAMPER + [OBJECT_EVENT_GFX_PICNICKER / 2] = 0x01, // OBJECT_EVENT_GFX_COOLTRAINER_M + [OBJECT_EVENT_GFX_COOLTRAINER_F / 2] = 0x01, // OBJECT_EVENT_GFX_SWIMMER_M_WATER + [OBJECT_EVENT_GFX_SWIMMER_F_WATER / 2] = 0x01, // OBJECT_EVENT_GFX_SWIMMER_M_LAND + [OBJECT_EVENT_GFX_SWIMMER_F_LAND / 2] = 0x01, // OBJECT_EVENT_GFX_WORKER_M + [OBJECT_EVENT_GFX_WORKER_F / 2] = 0x01, // OBJECT_EVENT_GFX_ROCKET_M + [OBJECT_EVENT_GFX_ROCKET_F / 2] = 0x01, // OBJECT_EVENT_GFX_GBA_KID + [OBJECT_EVENT_GFX_SUPER_NERD / 2] = 0x00, // OBJECT_EVENT_GFX_BIKER + [OBJECT_EVENT_GFX_BLACKBELT / 2] = 0x00, // OBJECT_EVENT_GFX_SCIENTIST + [OBJECT_EVENT_GFX_HIKER / 2] = 0x00, // OBJECT_EVENT_GFX_FISHER + [OBJECT_EVENT_GFX_CHANNELER / 2] = 0x01, // OBJECT_EVENT_GFX_CHEF + [OBJECT_EVENT_GFX_POLICEMAN / 2] = 0x00, // OBJECT_EVENT_GFX_GENTLEMAN + [OBJECT_EVENT_GFX_SAILOR / 2] = 0x00, // OBJECT_EVENT_GFX_CAPTAIN + [OBJECT_EVENT_GFX_NURSE / 2] = 0x11, // OBJECT_EVENT_GFX_CABLE_CLUB_RECEPTIONIST + [OBJECT_EVENT_GFX_UNION_ROOM_RECEPTIONIST / 2] = 0x01, // OBJECT_EVENT_GFX_UNUSED_MALE_RECEPTIONIST + [OBJECT_EVENT_GFX_CLERK / 2] = 0x00, // OBJECT_EVENT_GFX_MG_DELIVERYMAN + [OBJECT_EVENT_GFX_TRAINER_TOWER_DUDE / 2] = 0x00, // OBJECT_EVENT_GFX_PROF_OAK + [OBJECT_EVENT_GFX_BLUE / 2] = 0x00, // OBJECT_EVENT_GFX_BILL + [OBJECT_EVENT_GFX_LANCE / 2] = 0x10, // OBJECT_EVENT_GFX_AGATHA + [OBJECT_EVENT_GFX_DAISY / 2] = 0x11, // OBJECT_EVENT_GFX_LORELEI + [OBJECT_EVENT_GFX_MR_FUJI / 2] = 0x00, // OBJECT_EVENT_GFX_BRUNO + [OBJECT_EVENT_GFX_BROCK / 2] = 0x10, // OBJECT_EVENT_GFX_MISTY + [OBJECT_EVENT_GFX_LT_SURGE / 2] = 0x10, // OBJECT_EVENT_GFX_ERIKA + [OBJECT_EVENT_GFX_KOGA / 2] = 0x10, // OBJECT_EVENT_GFX_SABRINA + [OBJECT_EVENT_GFX_BLAINE / 2] = 0x00, // OBJECT_EVENT_GFX_GIOVANNI + [OBJECT_EVENT_GFX_MOM / 2] = 0x01, // OBJECT_EVENT_GFX_CELIO + [OBJECT_EVENT_GFX_TEACHY_TV_HOST / 2] = 0x00, // OBJECT_EVENT_GFX_GYM_GUY + [OBJECT_EVENT_GFX_ITEM_BALL / 2] = 0x33, // OBJECT_EVENT_GFX_TOWN_MAP + [OBJECT_EVENT_GFX_POKEDEX / 2] = 0x33, // OBJECT_EVENT_GFX_CUT_TREE + [OBJECT_EVENT_GFX_ROCK_SMASH_ROCK / 2] = 0x33, // OBJECT_EVENT_GFX_STRENGTH_BOULDER + [OBJECT_EVENT_GFX_FOSSIL / 2] = 0x33, // OBJECT_EVENT_GFX_RUBY + [OBJECT_EVENT_GFX_SAPPHIRE / 2] = 0x33, // OBJECT_EVENT_GFX_OLD_AMBER + [OBJECT_EVENT_GFX_GYM_SIGN / 2] = 0x33, // OBJECT_EVENT_GFX_SIGN + [OBJECT_EVENT_GFX_TRAINER_TIPS / 2] = 0x33, // OBJECT_EVENT_GFX_CLIPBOARD + [OBJECT_EVENT_GFX_METEORITE / 2] = 0x33, // OBJECT_EVENT_GFX_LAPRAS_DOLL + [OBJECT_EVENT_GFX_SEAGALLOP / 2] = 0x23, // OBJECT_EVENT_GFX_SNORLAX + [OBJECT_EVENT_GFX_SPEAROW / 2] = 0x22, // OBJECT_EVENT_GFX_CUBONE + [OBJECT_EVENT_GFX_POLIWRATH / 2] = 0x22, // OBJECT_EVENT_GFX_CLEFAIRY + [OBJECT_EVENT_GFX_PIDGEOT / 2] = 0x22, // OBJECT_EVENT_GFX_JIGGLYPUFF + [OBJECT_EVENT_GFX_PIDGEY / 2] = 0x22, // OBJECT_EVENT_GFX_CHANSEY + [OBJECT_EVENT_GFX_OMANYTE / 2] = 0x22, // OBJECT_EVENT_GFX_KANGASKHAN + [OBJECT_EVENT_GFX_PIKACHU / 2] = 0x22, // OBJECT_EVENT_GFX_PSYDUCK + [OBJECT_EVENT_GFX_NIDORAN_F / 2] = 0x22, // OBJECT_EVENT_GFX_NIDORAN_M + [OBJECT_EVENT_GFX_NIDORINO / 2] = 0x22, // OBJECT_EVENT_GFX_MEOWTH + [OBJECT_EVENT_GFX_SEEL / 2] = 0x22, // OBJECT_EVENT_GFX_VOLTORB + [OBJECT_EVENT_GFX_SLOWPOKE / 2] = 0x22, // OBJECT_EVENT_GFX_SLOWBRO + [OBJECT_EVENT_GFX_MACHOP / 2] = 0x22, // OBJECT_EVENT_GFX_WIGGLYTUFF + [OBJECT_EVENT_GFX_DODUO / 2] = 0x22, // OBJECT_EVENT_GFX_FEAROW + [OBJECT_EVENT_GFX_MACHOKE / 2] = 0x22, // OBJECT_EVENT_GFX_LAPRAS + [OBJECT_EVENT_GFX_ZAPDOS / 2] = 0x22, // OBJECT_EVENT_GFX_MOLTRES + [OBJECT_EVENT_GFX_ARTICUNO / 2] = 0x22, // OBJECT_EVENT_GFX_MEWTWO + [OBJECT_EVENT_GFX_MEW / 2] = 0x22, // OBJECT_EVENT_GFX_ENTEI + [OBJECT_EVENT_GFX_SUICUNE / 2] = 0x22, // OBJECT_EVENT_GFX_RAIKOU + [OBJECT_EVENT_GFX_LUGIA / 2] = 0x22, // OBJECT_EVENT_GFX_HO_OH + [OBJECT_EVENT_GFX_CELEBI / 2] = 0x22, // OBJECT_EVENT_GFX_KABUTO + [OBJECT_EVENT_GFX_DEOXYS_D / 2] = 0x22, // OBJECT_EVENT_GFX_DEOXYS_A + [OBJECT_EVENT_GFX_DEOXYS_N / 2] = 0x32, // OBJECT_EVENT_GFX_SS_ANNE }; void DynamicPlaceholderTextUtil_Reset(void) @@ -63,7 +136,7 @@ u8 GetColorFromTextColorTable(u16 graphicId) u32 test = graphicId >> 1; u32 shift = (graphicId & 1) << 2; - if (test > 0x4B) + if (test >= NELEMS(sTextColorTable)) return 3; else return (sTextColorTable[graphicId >> 1] >> shift) & 0xF; diff --git a/src/ereader_helpers.c b/src/ereader_helpers.c index cce6cefca..df1b1c279 100644 --- a/src/ereader_helpers.c +++ b/src/ereader_helpers.c @@ -1,25 +1,18 @@ #include "global.h" #include "link.h" -#include "unk_815c27c.h" - -enum { - EREADER_XFR_STATE_INIT, - EREADER_XFR_STATE_HANDSHAKE, - EREADER_XFR_STATE_START, - EREADER_XFR_STATE_TRANSFER, -}; +#include "ereader_helpers.h" struct SendRecvMgr { - u8 sendOrRecv; - u8 state; - u8 field_02; - u8 field_03; - u8 field_04; - u32 * dataptr; - int cursor; - int size; - u32 checksum; + u8 master_slave; // 0: clock slave; 1: clock master + u8 state; // EREADER_XFR_STATE_* + u8 xferState; // EREADER_XFER_* + u8 checksumResult; // EREADER_CHECKSUM_* + u8 cancellationReason; // EREADER_CANCEL_* + u32 * dataptr; // Payload source or destination + int cursor; // Index of the next word + int size; // Last word index + u32 checksum; // Validation checksum }; static bool16 DetermineSendRecvState(u8); @@ -39,10 +32,9 @@ static u16 sSavedIme; static u16 sSavedIe; static u16 sSavedTm3Cnt; static u16 sSavedSioCnt; -static u16 sSavedSioCnt; static u16 sSavedRCnt; -int EReader_Send(size_t r6, const void * r5) +int EReader_Send(size_t size, const void * src) { int result; EReaderHelper_SaveRegsState(); @@ -53,18 +45,18 @@ int EReader_Send(size_t r6, const void * r5) if (TEST_BUTTON(sJoyNew, B_BUTTON)) gShouldAdvanceLinkState = 2; - sSendRecvStatus = EReaderHandleTransfer(1, r6, r5, NULL); - if ((sSendRecvStatus & 0x13) == 0x10) + sSendRecvStatus = EReaderHandleTransfer(1, size, src, NULL); + if ((sSendRecvStatus & 0x13) == 0x10) // checksum OK and xfer off { result = 0; break; } - else if (sSendRecvStatus & 8) + else if (sSendRecvStatus & 8) // cancelled by player { result = 1; break; } - else if (sSendRecvStatus & 4) + else if (sSendRecvStatus & 4) // timed out { result = 2; break; @@ -81,7 +73,7 @@ int EReader_Send(size_t r6, const void * r5) return result; } -int EReader_Recv(void * r5) +int EReader_Recv(void * dest) { int result; EReaderHelper_SaveRegsState(); @@ -92,18 +84,18 @@ int EReader_Recv(void * r5) if (TEST_BUTTON(sJoyNew, B_BUTTON)) gShouldAdvanceLinkState = 2; - sSendRecvStatus = EReaderHandleTransfer(0, 0, NULL, r5); - if ((sSendRecvStatus & 0x13) == 0x10) + sSendRecvStatus = EReaderHandleTransfer(0, 0, NULL, dest); + if ((sSendRecvStatus & 0x13) == 0x10) // checksum OK and xfer off { result = 0; break; } - else if (sSendRecvStatus & 8) + else if (sSendRecvStatus & 8) // cancelled by player { result = 1; break; } - else if (sSendRecvStatus & 4) + else if (sSendRecvStatus & 4) // timed out { result = 2; break; @@ -159,92 +151,98 @@ u16 EReaderHandleTransfer(u8 mode, size_t size, const void * data, void * recvBu { switch (sSendRecvMgr.state) { - case 0: + case EREADER_XFR_STATE_INIT: OpenSerialMulti(); - sSendRecvMgr.field_02 = 1; - sSendRecvMgr.state = 1; + sSendRecvMgr.xferState = EREADER_XFER_EXE; + sSendRecvMgr.state = EREADER_XFR_STATE_HANDSHAKE; break; - case 1: + case EREADER_XFR_STATE_HANDSHAKE: if (DetermineSendRecvState(mode)) EnableSio(); if (gShouldAdvanceLinkState == 2) { - sSendRecvMgr.field_04 = 2; - sSendRecvMgr.state = 6; + sSendRecvMgr.cancellationReason = EREADER_CANCEL_KEY; + sSendRecvMgr.state = EREADER_XFR_STATE_DONE; } + // Progression is handled by the serial callback break; - case 2: + case EREADER_XFR_STATE_START: OpenSerial32(); SetUpTransferManager(size, data, recvBuffer); - sSendRecvMgr.state = 3; + sSendRecvMgr.state = EREADER_XFR_STATE_TRANSFER; // fallthrough - case 3: + case EREADER_XFR_STATE_TRANSFER: if (gShouldAdvanceLinkState == 2) { - sSendRecvMgr.field_04 = 2; - sSendRecvMgr.state = 6; + sSendRecvMgr.cancellationReason = EREADER_CANCEL_KEY; + sSendRecvMgr.state = EREADER_XFR_STATE_DONE; } else { sCounter1++; sCounter2++; - if (sSendRecvMgr.sendOrRecv == 0 && sCounter2 > 60) + if (sSendRecvMgr.master_slave == 0 && sCounter2 > 60) { - sSendRecvMgr.field_04 = 1; - sSendRecvMgr.state = 6; + sSendRecvMgr.cancellationReason = EREADER_CANCEL_TIMEOUT; + sSendRecvMgr.state = EREADER_XFR_STATE_DONE; } - if (sSendRecvMgr.field_02 != 2) + if (sSendRecvMgr.xferState != EREADER_XFER_CHK) { - if (sSendRecvMgr.sendOrRecv != 0 && sCounter1 > 2) + if (sSendRecvMgr.master_slave != 0 && sCounter1 > 2) { EnableSio(); - sSendRecvMgr.field_02 = 2; + sSendRecvMgr.xferState = EREADER_XFER_CHK; } else { EnableSio(); - sSendRecvMgr.field_02 = 2; + sSendRecvMgr.xferState = EREADER_XFER_CHK; } } } + // Progression is handled by the serial callback break; - case 4: + case EREADER_XFR_STATE_TRANSFER_DONE: OpenSerialMulti(); - sSendRecvMgr.state = 5; + sSendRecvMgr.state = EREADER_XFR_STATE_CHECKSUM; break; - case 5: - if (sSendRecvMgr.sendOrRecv == 1 && sCounter1 > 2) + case EREADER_XFR_STATE_CHECKSUM: + if (sSendRecvMgr.master_slave == 1 && sCounter1 > 2) EnableSio(); if (++sCounter1 > 60) { - sSendRecvMgr.field_04 = 1; - sSendRecvMgr.state = 6; + sSendRecvMgr.cancellationReason = EREADER_CANCEL_TIMEOUT; + sSendRecvMgr.state = EREADER_XFR_STATE_DONE; } break; - case 6: - if (sSendRecvMgr.field_02 != 0) + // Progression is handled by the serial callback + case EREADER_XFR_STATE_DONE: + if (sSendRecvMgr.xferState != 0) { CloseSerial(); - sSendRecvMgr.field_02 = 0; + sSendRecvMgr.xferState = 0; } break; } - return sSendRecvMgr.field_02 | (sSendRecvMgr.field_04 << 2) | (sSendRecvMgr.field_03 << 4); + return + (sSendRecvMgr.xferState << EREADER_XFER_SHIFT) + | (sSendRecvMgr.cancellationReason << EREADER_CANCEL_SHIFT) + | (sSendRecvMgr.checksumResult << EREADER_CHECKSUM_SHIFT); } static bool16 DetermineSendRecvState(u8 mode) { bool16 resp; if ((*(vu32 *)REG_ADDR_SIOCNT & (SIO_MULTI_SI | SIO_MULTI_SD)) == SIO_MULTI_SD && mode) - resp = sSendRecvMgr.sendOrRecv = TRUE; + resp = sSendRecvMgr.master_slave = TRUE; else - resp = sSendRecvMgr.sendOrRecv = FALSE; + resp = sSendRecvMgr.master_slave = FALSE; return resp; } static void SetUpTransferManager(size_t size, const void * data, void * recvBuffer) { - if (sSendRecvMgr.sendOrRecv) + if (sSendRecvMgr.master_slave) { REG_SIOCNT |= SIO_38400_BPS; sSendRecvMgr.dataptr = (void *)data; @@ -284,7 +282,7 @@ void EReaderHelper_SerialCallback(void) switch (sSendRecvMgr.state) { - case 1: + case EREADER_XFR_STATE_HANDSHAKE: REG_SIOMLT_SEND = 0xCCD0; *(u64 *)recv = REG_SIOMLT_RECV; for (i = 0, cnt1 = 0, cnt2 = 0; i < 4; i++) @@ -295,14 +293,17 @@ void EReaderHelper_SerialCallback(void) cnt2++; } if (cnt1 == 2 && cnt2 == 0) - sSendRecvMgr.state = 2; + sSendRecvMgr.state = EREADER_XFR_STATE_START; break; - case 3: + // Progression is handled by software + case EREADER_XFR_STATE_TRANSFER: recv32 = REG_SIODATA32; - if (sSendRecvMgr.cursor == 0 && sSendRecvMgr.sendOrRecv == 0) + // The first value sent by the EReader is the payload size + if (sSendRecvMgr.cursor == 0 && sSendRecvMgr.master_slave == 0) sSendRecvMgr.size = recv32 / 4 + 1; - if (sSendRecvMgr.sendOrRecv == 1) + if (sSendRecvMgr.master_slave == 1) { + // Send mode if (sSendRecvMgr.cursor < sSendRecvMgr.size) { REG_SIODATA32 = sSendRecvMgr.dataptr[sSendRecvMgr.cursor]; @@ -313,43 +314,51 @@ void EReaderHelper_SerialCallback(void) } else { + // Receive mode if (sSendRecvMgr.cursor > 0 && sSendRecvMgr.cursor < sSendRecvMgr.size + 1) { + // Receive next word sSendRecvMgr.dataptr[sSendRecvMgr.cursor - 1] = recv32; sSendRecvMgr.checksum += recv32; } else if (sSendRecvMgr.cursor != 0) { + // Reached the end, test the received checksum if (sSendRecvMgr.checksum == recv32) - sSendRecvMgr.field_03 = 1; + sSendRecvMgr.checksumResult = EREADER_CHECKSUM_OK; else - sSendRecvMgr.field_03 = 2; + sSendRecvMgr.checksumResult = EREADER_CHECKSUM_ERR; } sCounter2 = 0; } sSendRecvMgr.cursor++; if (sSendRecvMgr.cursor < sSendRecvMgr.size + 2) { - if (sSendRecvMgr.sendOrRecv != 0) + if (sSendRecvMgr.master_slave != 0) + // Clock master; start timer REG_TM3CNT_H |= TIMER_ENABLE; else + // Clock slave; reset EnableSio(); } else { - sSendRecvMgr.state = 4; + sSendRecvMgr.state = EREADER_XFR_STATE_TRANSFER_DONE; sCounter1 = 0; } break; - case 5: - if (sSendRecvMgr.sendOrRecv == 0) - REG_SIODATA8 = sSendRecvMgr.field_03; + // Progression is handled by the software + case EREADER_XFR_STATE_CHECKSUM: + if (sSendRecvMgr.master_slave == 0) + // Clock slave + REG_SIODATA8 = sSendRecvMgr.checksumResult; *(vu64 *)recv = REG_SIOMLT_RECV; - if (recv[1] == 1 || recv[1] == 2) + if (recv[1] == EREADER_CHECKSUM_OK || recv[1] == EREADER_CHECKSUM_ERR) { - if (sSendRecvMgr.sendOrRecv == 1) - sSendRecvMgr.field_03 = recv[1]; - sSendRecvMgr.state = 6; + if (sSendRecvMgr.master_slave == 1) + // EReader has (in)validated the payload + sSendRecvMgr.checksumResult = recv[1]; + sSendRecvMgr.state = EREADER_XFR_STATE_DONE; } break; } diff --git a/src/event_data.c b/src/event_data.c index 010a4414c..74d1cf608 100644 --- a/src/event_data.c +++ b/src/event_data.c @@ -118,7 +118,7 @@ bool32 IsMysteryGiftEnabled(void) return FlagGet(FLAG_SYS_MYSTERY_GIFT_ENABLED); } -void sub_806E2D0(void) +void ResetMysteryEventFlags(void) { FlagClear(FLAG_MYSTERY_EVENT_DONE); FlagClear(FLAG_0x3D9); @@ -138,7 +138,7 @@ void sub_806E2D0(void) FlagClear(FLAG_0x3E7); } -void sub_806E370(void) +void ResetMysteryEventVars(void) { VarSet(VAR_EVENT_PICHU_SLOT, 0); VarSet(VAR_0x40B6, 0); diff --git a/src/event_object_80688E4.c b/src/event_object_80688E4.c index 133052642..2d79c4f7b 100644 --- a/src/event_object_80688E4.c +++ b/src/event_object_80688E4.c @@ -524,12 +524,12 @@ void RfuUnionObjectSetFacingDirection(u8 objectEventId, u8 direction) } } -void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 arg1) +void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 invisible) { u8 spriteId = GetObjectEventSpriteId(objectEventId); if (spriteId != MAX_SPRITES) { - if (arg1) + if (invisible) gSprites[spriteId].tInvisible = TRUE; else gSprites[spriteId].tInvisible = FALSE; @@ -544,12 +544,12 @@ bool32 RfuUnionObjectIsInvisible(u8 objectEventId) return gSprites[spriteId].tInvisible == TRUE; } -void RfuUnionObjectStartWarp(u8 objectEventId, u8 direction) +void RfuUnionObjectStartWarp(u8 objectEventId, u8 animNo) { u8 spriteId = GetObjectEventSpriteId(objectEventId); if (spriteId != MAX_SPRITES) { - gSprites[spriteId].tUnionRoomWarpAnimNo = direction; + gSprites[spriteId].tUnionRoomWarpAnimNo = animNo; gSprites[spriteId].tUnionRoomWarpAnimState = 0; } } diff --git a/src/event_object_lock.c b/src/event_object_lock.c index cf500054f..304b71c28 100644 --- a/src/event_object_lock.c +++ b/src/event_object_lock.c @@ -93,7 +93,7 @@ void sub_80696C0(void) UnfreezeObjectEvents(); } -void sub_80696F0(void) +void UnionRoom_UnlockPlayerAndChatPartner(void) { u8 objectEventId; if (gObjectEvents[gSelectedObjectEvent].active) diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c index 42fe26c91..2e1dcd919 100644 --- a/src/field_fadetransition.c +++ b/src/field_fadetransition.c @@ -206,7 +206,7 @@ static void sub_807DDF0(u8 taskId) switch (task->data[0]) { case 0: - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); task->data[0]++; break; case 1: @@ -227,7 +227,7 @@ static void sub_807DDF0(u8 taskId) } } -void sub_807DE58(void) +void FieldCB_ReturnToFieldWirelessLink(void) { ScriptContext2_Enable(); Overworld_PlaySpecialMapMusic(); @@ -632,7 +632,7 @@ static void sub_807E5EC(u8 taskId) break; case 2: WarpIntoMap(); - SetMainCallback2(sub_8056788); + SetMainCallback2(CB2_ReturnToFieldCableClub); DestroyTask(taskId); break; } @@ -662,7 +662,7 @@ static void sub_807E678(u8 taskId) case 1: if (!sub_807E40C() && BGMusicStopped()) { - sub_800AAC0(); + Link_TryStartSend5FFF(); data[0]++; } break; diff --git a/src/field_specials.c b/src/field_specials.c index bb320d42a..bd19a0477 100644 --- a/src/field_specials.c +++ b/src/field_specials.c @@ -1920,15 +1920,15 @@ u16 Special_BattleCardAction(void) switch (gSpecialVar_Result) { case 0: - return sub_81445C0(3); + return MEvent_GetBattleCardCount(3); case 1: - return sub_81445C0(4); + return MEvent_GetBattleCardCount(4); case 2: - return sub_81445C0(0); + return MEvent_GetBattleCardCount(0); case 3: - return sub_81445C0(1); + return MEvent_GetBattleCardCount(1); case 4: - return sub_81445C0(2); + return MEvent_GetBattleCardCount(2); default: AGB_ASSERT_EX(0, ABSPATH("scr_tool.c"), 3873); return 0; diff --git a/src/fieldmap.c b/src/fieldmap.c index adb26f230..0844087e0 100644 --- a/src/fieldmap.c +++ b/src/fieldmap.c @@ -490,7 +490,7 @@ void MapGridSetMetatileEntryAt(s32 x, s32 y, u16 metatile) } } -void sub_8059024(s32 x, s32 y, bool32 arg2) +void MapGridSetMetatileImpassabilityAt(s32 x, s32 y, bool32 arg2) { if (x >= 0 && x < VMap.Xsize && y >= 0 && y < VMap.Ysize) diff --git a/src/help_system.c b/src/help_system.c index 4a4d927c5..bb3135260 100644 --- a/src/help_system.c +++ b/src/help_system.c @@ -33,7 +33,7 @@ struct HelpSystemVideoState static EWRAM_DATA u8 sMapTilesBackup[BG_CHAR_SIZE] = {0}; EWRAM_DATA u8 gUnknown_203F174 = 0; -EWRAM_DATA u8 gUnknown_203F175 = 0; +EWRAM_DATA bool8 gHelpSystemToggleWithRButtonDisabled = FALSE; static EWRAM_DATA u8 sDelayTimer = 0; static EWRAM_DATA u8 sInHelpSystem = 0; static EWRAM_DATA struct HelpSystemVideoState sVideoState = {0}; @@ -53,7 +53,7 @@ u8 RunHelpSystemCallback(void) sInHelpSystem = 0; if (gSaveBlock2Ptr->optionsButtonMode != OPTIONS_BUTTON_MODE_HELP) return 0; - if (JOY_NEW(R_BUTTON) && gUnknown_203F175 == 1) + if (JOY_NEW(R_BUTTON) && gHelpSystemToggleWithRButtonDisabled == TRUE) return 0; if (JOY_NEW(L_BUTTON | R_BUTTON)) { @@ -93,9 +93,9 @@ u8 RunHelpSystemCallback(void) HelpSystem_PrintText_Row61(gString_Help); sub_813BD14(1); if (sub_812B40C() == TRUE) - sub_812BC54(&gHelpSystemListMenu, gHelpSystemListMenuItems); + HelpSystemSubroutine_PrintWelcomeMessage(&gHelpSystemListMenu, gHelpSystemListMenuItems); else - sub_812BCA8(&gHelpSystemListMenu, gHelpSystemListMenuItems); + HelpSystemSubroutine_WelcomeEndGotoMenu(&gHelpSystemListMenu, gHelpSystemListMenuItems); sub_813BE78(1); sub_813BF50(1); CommitTilemap(); @@ -110,7 +110,7 @@ u8 RunHelpSystemCallback(void) sVideoState.state = 5; break; case 5: - if (!sub_812BB9C(&gHelpSystemListMenu, gHelpSystemListMenuItems)) + if (!RunHelpMenuSubroutine(&gHelpSystemListMenu, gHelpSystemListMenuItems)) { PlaySE(SE_HELP_CL); sVideoState.state = 6; @@ -981,9 +981,9 @@ void HelpSystem_FillPanel1(void) void HelpSystem_InitListMenuController(struct HelpSystemListMenu * a0, u8 a1, u8 a2) { gHelpSystemListMenu.sub = a0->sub; - gHelpSystemListMenu.field_0C = a1; - gHelpSystemListMenu.field_0D = a2; - gHelpSystemListMenu.field_0E = 0; + gHelpSystemListMenu.itemsAbove = a1; + gHelpSystemListMenu.cursorPos = a2; + gHelpSystemListMenu.state = 0; if (gHelpSystemListMenu.sub.totalItems < gHelpSystemListMenu.sub.maxShowed) gHelpSystemListMenu.sub.maxShowed = gHelpSystemListMenu.sub.totalItems; sub_813BDA4(0); @@ -1007,7 +1007,7 @@ s32 HelpSystem_GetMenuInput(void) else if (JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - return gHelpSystemListMenu.sub.items[gHelpSystemListMenu.field_0C + gHelpSystemListMenu.field_0D].index; + return gHelpSystemListMenu.sub.items[gHelpSystemListMenu.itemsAbove + gHelpSystemListMenu.cursorPos].index; } else if (JOY_NEW(B_BUTTON)) { @@ -1051,15 +1051,15 @@ void sub_813C75C(void) u8 r6 = gHelpSystemListMenu.sub.totalItems - 7; if (gHelpSystemListMenu.sub.totalItems > 7) { - s32 r4 = gHelpSystemListMenu.field_0C + gHelpSystemListMenu.field_0D; + s32 r4 = gHelpSystemListMenu.itemsAbove + gHelpSystemListMenu.cursorPos; sub_813C004(0, 0); if (r4 == 0) sub_813C004(1, 1); - else if (gHelpSystemListMenu.field_0C == 0 && gHelpSystemListMenu.field_0D != 0) + else if (gHelpSystemListMenu.itemsAbove == 0 && gHelpSystemListMenu.cursorPos != 0) sub_813C004(1, 1); - else if (gHelpSystemListMenu.field_0C == r6) + else if (gHelpSystemListMenu.itemsAbove == r6) sub_813C004(0, 1); - else if (gHelpSystemListMenu.field_0C != 0) + else if (gHelpSystemListMenu.itemsAbove != 0) { sub_813C004(0, 1); sub_813C004(1, 1); @@ -1071,7 +1071,7 @@ void PrintListMenuItems(void) { u8 glyphHeight = GetFontAttribute(2, 1) + 1; s32 i; - s32 r5 = gHelpSystemListMenu.field_0C; + s32 r5 = gHelpSystemListMenu.itemsAbove; for (i = 0; i < gHelpSystemListMenu.sub.maxShowed; i++) { @@ -1086,7 +1086,7 @@ void PlaceListMenuCursor(void) { u8 glyphHeight = GetFontAttribute(2, 1) + 1; u8 x = gHelpSystemListMenu.sub.left; - u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.field_0D; + u8 y = gHelpSystemListMenu.sub.top + glyphHeight * gHelpSystemListMenu.cursorPos; HelpSystem_PrintTextAt(gFameCheckerText_ListMenuCursor, x, y); } @@ -1107,24 +1107,24 @@ u8 TryMoveCursor1(u8 dirn) r4 = 0; else r4 = gHelpSystemListMenu.sub.maxShowed - (gHelpSystemListMenu.sub.maxShowed / 2 + (gHelpSystemListMenu.sub.maxShowed & 1)) - 1; - if (gHelpSystemListMenu.field_0C == 0) + if (gHelpSystemListMenu.itemsAbove == 0) { - if (gHelpSystemListMenu.field_0D != 0) + if (gHelpSystemListMenu.cursorPos != 0) { - gHelpSystemListMenu.field_0D--; + gHelpSystemListMenu.cursorPos--; return 1; } else return 0; } - if (gHelpSystemListMenu.field_0D > r4) + if (gHelpSystemListMenu.cursorPos > r4) { - gHelpSystemListMenu.field_0D--; + gHelpSystemListMenu.cursorPos--; return 1; } else { - gHelpSystemListMenu.field_0C--; + gHelpSystemListMenu.itemsAbove--; return 2; } } @@ -1134,24 +1134,24 @@ u8 TryMoveCursor1(u8 dirn) r4 = 0; else r4 = gHelpSystemListMenu.sub.maxShowed / 2 + (gHelpSystemListMenu.sub.maxShowed & 1); - if (gHelpSystemListMenu.field_0C == gHelpSystemListMenu.sub.totalItems - gHelpSystemListMenu.sub.maxShowed) + if (gHelpSystemListMenu.itemsAbove == gHelpSystemListMenu.sub.totalItems - gHelpSystemListMenu.sub.maxShowed) { - if (gHelpSystemListMenu.field_0D < gHelpSystemListMenu.sub.maxShowed - 1) + if (gHelpSystemListMenu.cursorPos < gHelpSystemListMenu.sub.maxShowed - 1) { - gHelpSystemListMenu.field_0D++; + gHelpSystemListMenu.cursorPos++; return 1; } else return 0; } - else if (gHelpSystemListMenu.field_0D < r4) + else if (gHelpSystemListMenu.cursorPos < r4) { - gHelpSystemListMenu.field_0D++; + gHelpSystemListMenu.cursorPos++; return 1; } else { - gHelpSystemListMenu.field_0C++; + gHelpSystemListMenu.itemsAbove++; return 2; } } @@ -1159,7 +1159,7 @@ u8 TryMoveCursor1(u8 dirn) bool8 MoveCursor(u8 by, u8 dirn) { - u8 r7 = gHelpSystemListMenu.field_0D; + u8 r7 = gHelpSystemListMenu.cursorPos; u8 flags = 0; s32 i; for (i = 0; i < by; i++) @@ -1172,14 +1172,14 @@ bool8 MoveCursor(u8 by, u8 dirn) // neither changed return TRUE; case 1: - // changed field_0D only + // changed cursorPos only sub_813C860(r7); PlaceListMenuCursor(); CommitTilemap(); break; case 2: case 3: - // changed field_0C + // changed itemsAbove if (sub_812BF88() == TRUE) { HelpSystem_SetInputDelay(2); diff --git a/src/help_system_812B1E0.c b/src/help_system_812B1E0.c index df892152a..5b634a273 100644 --- a/src/help_system_812B1E0.c +++ b/src/help_system_812B1E0.c @@ -19,22 +19,22 @@ static EWRAM_DATA u16 sSomeVariable = 0; static EWRAM_DATA u8 gUnknown_203B0EE = 0; -u8 gUnknown_3005E9C[4]; +u8 sHelpSystemState[4]; u16 gSomeVariableBackup; static bool32 IsCurrentMapInArray(const u16 * mapIdxs); -static void sub_812B520(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); -static void sub_812B614(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); -static bool8 sub_812B754(void); -static bool8 sub_812B780(u8); -static bool8 sub_812BB10(void); - -static void sub_812BF5C(void); -static void sub_812BF74(const u8 *); -static void sub_812BF94(struct HelpSystemListMenu * a0); -static void sub_812BF9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); - -static const u8 *const gUnknown_845B080[] = { +static void BuildMainTopicsListAndMoveToH00(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); +static void SetHelpSystemSubmenuItems(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); +static bool8 HelpSystem_HasDefeatedBrock(void); +static bool8 HelpSystemSubmenuIndexIsActive(u8); +static bool8 HasGottenAtLeastOneHM(void); + +static void PrintWelcomeMessageOnPanel1(void); +static void PrintTextOnPanel2Row52RightAlign(const u8 *); +static void ResetHelpSystemCursor(struct HelpSystemListMenu * a0); +static void PrintHelpSystemTopicMouseoverDescription(struct HelpSystemListMenu * a0, struct ListMenuItem * a1); + +static const u8 *const sHelpSystemTopicPtrs[] = { gUnknown_81B2DF8, gUnknown_81B2E1C, gUnknown_81B2E2E, @@ -43,7 +43,7 @@ static const u8 *const gUnknown_845B080[] = { gUnknown_81B2E6A }; -static const u8 *const gUnknown_845B098[] = { +static const u8 *const sHelpSystemTopicMouseoverDescriptionPtrs[] = { gUnknown_81B2E88, gUnknown_81B2EC8, gUnknown_81B2F00, @@ -52,7 +52,7 @@ static const u8 *const gUnknown_845B098[] = { gUnknown_81B2FA9 }; -static const u8 *const gUnknown_845B0B0[] = { +static const u8 *const sHelpSystemSpecializedQuestionTextPtrs[] = { NULL, gUnknown_81B3083, gUnknown_81B30A9, @@ -100,7 +100,7 @@ static const u8 *const gUnknown_845B0B0[] = { gUnknown_81B3516 }; -static const u8 *const gUnknown_845B164[] = { +static const u8 *const sHelpSystemSpecializedAnswerTextPtrs[] = { NULL, gUnknown_81B3525, gUnknown_81B35E6, @@ -148,7 +148,7 @@ static const u8 *const gUnknown_845B164[] = { gUnknown_81B55F4 }; -static const u8 *const gUnknown_845B218[] = { +static const u8 *const sHelpSystemMenuTopicTextPtrs[] = { NULL, gUnknown_81B56E3, gUnknown_81B56F4, @@ -200,7 +200,7 @@ static const u8 *const gUnknown_845B218[] = { gUnknown_81B5A37 }; -static const u8 *const gUnknown_845B2DC[] = { +static const u8 *const sHelpSystemSpecializedControlsTextPtrs[] = { NULL, gUnknown_81B5A4D, gUnknown_81B5B0C, @@ -252,7 +252,7 @@ static const u8 *const gUnknown_845B2DC[] = { gUnknown_81B7C57 }; -static const u8 *const gUnknown_845B3A0[] = { +static const u8 *const sHelpSystemSpecializedStringsTextPtrs[] = { NULL, gUnknown_81B7CC1, gUnknown_81B7CC4, @@ -299,7 +299,7 @@ static const u8 *const gUnknown_845B3A0[] = { gUnknown_81B7E0F }; -static const u8 *const gUnknown_845B450[] = { +static const u8 *const sHelpSystemSpecializedStringDefinitionsTextPtrs[] = { NULL, gUnknown_81B7E16, gUnknown_81B7F0A, @@ -346,7 +346,7 @@ static const u8 *const gUnknown_845B450[] = { gUnknown_81B9B2F }; -static const u8 *const gUnknown_845B500[] = { +static const u8 *const sHelpSystemGeneralTopicTextPtrs[] = { NULL, gUnknown_81B9BB7, gUnknown_81B9BC7, @@ -357,7 +357,7 @@ static const u8 *const gUnknown_845B500[] = { gUnknown_81B9C1D }; -static const u8 *const gUnknown_845B520[] = { +static const u8 *const sHelpSystemGeneralTopicDescriptionTextPtrs[] = { NULL, gUnknown_81B9C2F, gUnknown_81B9D04, @@ -368,7 +368,7 @@ static const u8 *const gUnknown_845B520[] = { gUnknown_81BA027 }; -static const u8 *const gUnknown_845B540[] = { +static const u8 *const sHelpSystemTypeMatchupTextPtrs[] = { NULL, gUnknown_81BA0F1, gUnknown_81BA10D, @@ -407,7 +407,7 @@ static const u8 *const gUnknown_845B540[] = { gUnknown_81BA400 }; -static const u8 *const gUnknown_845B5D0[] = { +static const u8 *const sHelpSystemTypeMatchupDescriptionTextPtrs[] = { NULL, gUnknown_81BA416, gUnknown_81BA4E6, @@ -446,7 +446,6 @@ static const u8 *const gUnknown_845B5D0[] = { gUnknown_81BB156 }; - static const u8 gUnknown_845B660[] = { 0x01, 0x02, 0x03, 0xff }; @@ -739,7 +738,7 @@ static const u8 gUnknown_845B9BE[] = { 0x09, 0x01, 0x02, 0x03, 0x23, 0x25, 0x24, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0b, 0x0c, 0x0d, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x27, 0x15, 0x26, 0x16, 0x17, 0x18, 0x1a, 0x0e, 0x1b, 0xff }; -static const u8 *const gUnknown_845B9E0[] = { +static const u8 *const sHelpSystemSubmenuIndexPointers[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, gUnknown_845B660, NULL, NULL, NULL, NULL, gUnknown_845B664, NULL, @@ -780,48 +779,48 @@ static const u8 *const gUnknown_845B9E0[] = { static const u16 unref_845BCB0[] = INCBIN_U16("graphics/help_system/unk_845BCB0.bin"); -static const u8 gUnknown_845C4B0[] = { +static const u8 sHelpSystemContextTopicOrder[] = { 3, 0, 1, 2, 4, 5 }; -static const u8 gUnknown_845C4B6[][6] = { - {0, 0, 0, 0, 0, 1}, - {0, 0, 0, 1, 0, 1}, - {0, 0, 0, 1, 0, 1}, - {0, 1, 0, 1, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {0, 0, 1, 0, 0, 1}, - {0, 0, 1, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {0, 1, 1, 0, 0, 1}, - {1, 0, 0, 1, 0, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 1, 0, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 0, 1, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 0, 0, 1}, - {1, 1, 1, 0, 1, 1}, - {1, 1, 1, 0, 1, 1}, - {1, 1, 1, 0, 1, 1}, - {1, 1, 1, 0, 1, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 1, 0, 0, 0, 1}, - {0, 0, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0} +static const bool8 sHelpSystemContextTopicFlags[][6] = { + {FALSE, FALSE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, FALSE, FALSE, TRUE, FALSE, TRUE }, + {FALSE, FALSE, FALSE, TRUE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, TRUE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, FALSE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, FALSE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, FALSE, FALSE, TRUE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, TRUE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, TRUE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, FALSE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, TRUE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, TRUE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, TRUE, TRUE }, + {TRUE, TRUE, TRUE, FALSE, TRUE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, + {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE}, + {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE} }; static const u16 sMartMaps[] = { @@ -961,12 +960,12 @@ static bool8 IsInDungeonMap(void) void sub_812B35C(void) { - sub_812B4B8(); + HelpSystem_EnableToggleWithRButton(); if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) HelpSystem_SetSomeVariable2(0x16); else if (IsInDungeonMap()) HelpSystem_SetSomeVariable2(0x15); - else if (is_light_level_8_or_9(gMapHeader.mapType)) + else if (IsMapTypeIndoors(gMapHeader.mapType)) { if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_1F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_1F)) || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(PALLET_TOWN_PLAYERS_HOUSE_2F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(PALLET_TOWN_PLAYERS_HOUSE_2F))) HelpSystem_SetSomeVariable2(0x0E); @@ -1015,126 +1014,126 @@ void HelpSystem_Enable(void) if (gQuestLogState != 2 && gQuestLogState != 3) { gHelpSystemEnabled = TRUE; - sub_812B4B8(); + HelpSystem_EnableToggleWithRButton(); } } -void sub_812B4AC(void) +void HelpSystem_DisableToggleWithRButton(void) { - gUnknown_203F175 = 1; + gHelpSystemToggleWithRButtonDisabled = TRUE; } -void sub_812B4B8(void) +void HelpSystem_EnableToggleWithRButton(void) { - gUnknown_203F175 = 0; + gHelpSystemToggleWithRButtonDisabled = FALSE; } -static void sub_812B4C4(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void ResetHelpSystemListMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - a0->sub.items = a1; - a0->sub.totalItems = 1; - a0->sub.maxShowed = 1; - a0->sub.left = 1; - a0->sub.top = 4; + helpListMenu->sub.items = listMenuItemsBuffer; + helpListMenu->sub.totalItems = 1; + helpListMenu->sub.maxShowed = 1; + helpListMenu->sub.left = 1; + helpListMenu->sub.top = 4; } -static void sub_812B4D8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void BuildAndPrintMainTopicsListMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - sub_812B4C4(a0, a1); - sub_812B520(a0, a1); - sub_812BF74(gUnknown_841DFAC); - HelpSystem_InitListMenuController(a0, 0, gUnknown_3005E9C[2]); - sub_812BF9C(a0, a1); + ResetHelpSystemListMenu(helpListMenu, listMenuItemsBuffer); + BuildMainTopicsListAndMoveToH00(helpListMenu, listMenuItemsBuffer); + PrintTextOnPanel2Row52RightAlign(gUnknown_841DFAC); + HelpSystem_InitListMenuController(helpListMenu, 0, sHelpSystemState[2]); + PrintHelpSystemTopicMouseoverDescription(helpListMenu, listMenuItemsBuffer); sub_813BDA4(1); sub_813BD5C(1); } -static void sub_812B520(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void BuildMainTopicsListAndMoveToH00(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { u8 i; - u8 r4 = 0; + u8 totalItems = 0; for (i = 0; i < 6; i++) { - if (gUnknown_845C4B6[sSomeVariable][gUnknown_845C4B0[i]] == 1) + if (sHelpSystemContextTopicFlags[sSomeVariable][sHelpSystemContextTopicOrder[i]] == TRUE) { - a1[r4].label = gUnknown_845B080[gUnknown_845C4B0[i]]; - a1[r4].index = gUnknown_845C4B0[i]; - r4++; + listMenuItemsBuffer[totalItems].label = sHelpSystemTopicPtrs[sHelpSystemContextTopicOrder[i]]; + listMenuItemsBuffer[totalItems].index = sHelpSystemContextTopicOrder[i]; + totalItems++; } } - a1[r4 - 1].index = -2; - a0->sub.totalItems = r4; - a0->sub.maxShowed = r4; - a0->sub.left = 0; + listMenuItemsBuffer[totalItems - 1].index = -2; + helpListMenu->sub.totalItems = totalItems; + helpListMenu->sub.maxShowed = totalItems; + helpListMenu->sub.left = 0; } -static void sub_812B5A8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void BuildAndPrintSubmenuList(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { sub_813BDE8(0); sub_813BFC0(0); sub_813BE78(1); - sub_812B4C4(a0, a1); - sub_812B614(a0, a1); - sub_812BF74(gUnknown_841DFC9); - HelpSystem_InitListMenuController(a0, a0->field_0C, a0->field_0D); - HelpSystem_PrintTextAt(gUnknown_845B080[gUnknown_3005E9C[1]], 0, 0); + ResetHelpSystemListMenu(helpListMenu, listMenuItemsBuffer); + SetHelpSystemSubmenuItems(helpListMenu, listMenuItemsBuffer); + PrintTextOnPanel2Row52RightAlign(gUnknown_841DFC9); + HelpSystem_InitListMenuController(helpListMenu, helpListMenu->itemsAbove, helpListMenu->cursorPos); + HelpSystem_PrintTextAt(sHelpSystemTopicPtrs[sHelpSystemState[1]], 0, 0); sub_813BDA4(1); sub_813BD5C(1); } -static void sub_812B614(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void SetHelpSystemSubmenuItems(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - u8 r6 = 0; - const u8 * r3 = gUnknown_845B9E0[sSomeVariable * 5 + gUnknown_3005E9C[1]]; + u8 totalItems = 0; + const u8 * indexPtr = sHelpSystemSubmenuIndexPointers[sSomeVariable * 5 + sHelpSystemState[1]]; u8 i; - for (i = 0; r3[i] != 0xFF; i++) + for (i = 0; indexPtr[i] != 0xFF; i++) { - if (sub_812B780(r3[i]) == TRUE) + if (HelpSystemSubmenuIndexIsActive(indexPtr[i]) == TRUE) { - if (gUnknown_3005E9C[1] == 0) - a1[r6].label = gUnknown_845B0B0[r3[i]]; - else if (gUnknown_3005E9C[1] == 1) - a1[r6].label = gUnknown_845B218[r3[i]]; - else if (gUnknown_3005E9C[1] == 2) - a1[r6].label = gUnknown_845B3A0[r3[i]]; - else if (gUnknown_3005E9C[1] == 3) - a1[r6].label = gUnknown_845B500[r3[i]]; + if (sHelpSystemState[1] == 0) + listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedQuestionTextPtrs[indexPtr[i]]; + else if (sHelpSystemState[1] == 1) + listMenuItemsBuffer[totalItems].label = sHelpSystemMenuTopicTextPtrs[indexPtr[i]]; + else if (sHelpSystemState[1] == 2) + listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedStringsTextPtrs[indexPtr[i]]; + else if (sHelpSystemState[1] == 3) + listMenuItemsBuffer[totalItems].label = sHelpSystemGeneralTopicTextPtrs[indexPtr[i]]; else - a1[r6].label = gUnknown_845B540[r3[i]]; - a1[r6].index = r3[i]; - r6++; + listMenuItemsBuffer[totalItems].label = sHelpSystemTypeMatchupTextPtrs[indexPtr[i]]; + listMenuItemsBuffer[totalItems].index = indexPtr[i]; + totalItems++; } } - if (sub_812B754() == TRUE) + if (HelpSystem_HasDefeatedBrock() == TRUE) { - for (i = 0, r3 = gUnknown_845B9BE; r3[i] != 0xFF; i++) + for (i = 0, indexPtr = gUnknown_845B9BE; indexPtr[i] != 0xFF; i++) { - a1[r6].label = gUnknown_845B3A0[r3[i]]; - a1[r6].index = r3[i]; - r6++; + listMenuItemsBuffer[totalItems].label = sHelpSystemSpecializedStringsTextPtrs[indexPtr[i]]; + listMenuItemsBuffer[totalItems].index = indexPtr[i]; + totalItems++; } } - a1[r6].label = gUnknown_81B2E6F; - a1[r6].index = -2; - r6++; - a0->sub.totalItems = r6; - a0->sub.maxShowed = 7; - a0->sub.left = 0; - a0->sub.top = 21; + listMenuItemsBuffer[totalItems].label = gUnknown_81B2E6F; + listMenuItemsBuffer[totalItems].index = -2; + totalItems++; + helpListMenu->sub.totalItems = totalItems; + helpListMenu->sub.maxShowed = 7; + helpListMenu->sub.left = 0; + helpListMenu->sub.top = 21; } -static bool8 sub_812B754(void) +static bool8 HelpSystem_HasDefeatedBrock(void) { - if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && gUnknown_3005E9C[1] == 2) + if (FlagGet(FLAG_DEFEATED_BROCK) == TRUE && sHelpSystemState[1] == 2) return TRUE; return FALSE; } -static bool8 sub_812B780(u8 id) +static bool8 HelpSystemSubmenuIndexIsActive(u8 id) { u8 i = 0; - if (gUnknown_3005E9C[1] == 0) + if (sHelpSystemState[1] == 0) { switch (id) { @@ -1188,7 +1187,7 @@ static bool8 sub_812B780(u8 id) return FlagGet(FLAG_BADGE01_GET); case 28: case 40: - return sub_812BB10(); + return HasGottenAtLeastOneHM(); case 39: return FlagGet(FLAG_GOT_FAME_CHECKER); case 44: @@ -1196,7 +1195,7 @@ static bool8 sub_812B780(u8 id) } return FALSE; } - if (gUnknown_3005E9C[1] == 1) + if (sHelpSystemState[1] == 1) { switch (id) { @@ -1254,7 +1253,7 @@ static bool8 sub_812B780(u8 id) return FlagGet(FLAG_BADGE01_GET); case 16: case 17: - return sub_812BB10(); + return HasGottenAtLeastOneHM(); case 18: return FlagGet(FLAG_GOT_BICYCLE); case 48: @@ -1262,9 +1261,9 @@ static bool8 sub_812B780(u8 id) } return FALSE; } - if (gUnknown_3005E9C[1] == 2) + if (sHelpSystemState[1] == 2) { - if (sub_812B754() == TRUE) + if (HelpSystem_HasDefeatedBrock() == TRUE) { for (i = 0; gUnknown_845B9BE[i] != 0xFF; i++) { @@ -1311,7 +1310,7 @@ static bool8 sub_812B780(u8 id) return FlagGet(FLAG_SYS_POKEMON_GET); case 36: case 37: - return sub_812BB10(); + return HasGottenAtLeastOneHM(); case 3: case 15: case 18: @@ -1320,7 +1319,7 @@ static bool8 sub_812B780(u8 id) } return TRUE; } - if (gUnknown_3005E9C[1] == 3) + if (sHelpSystemState[1] == 3) { switch (id) { @@ -1331,7 +1330,7 @@ static bool8 sub_812B780(u8 id) } return TRUE; } - if (gUnknown_3005E9C[1] == 4) + if (sHelpSystemState[1] == 4) { return TRUE; } @@ -1339,7 +1338,7 @@ static bool8 sub_812B780(u8 id) return FALSE; } -static bool8 sub_812BB10(void) +static bool8 HasGottenAtLeastOneHM(void) { if (FlagGet(FLAG_GOT_HM01) == TRUE) return TRUE; @@ -1358,64 +1357,64 @@ static bool8 sub_812BB10(void) return FALSE; } -bool8 sub_812BB9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 RunHelpMenuSubroutine(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - switch (a0->field_0E) + switch (helpListMenu->state) { case 8: - return sub_812BC54(a0, a1); + return HelpSystemSubroutine_PrintWelcomeMessage(helpListMenu, listMenuItemsBuffer); case 9: - return sub_812BC80(a0, a1); + return HelpSystemSubroutine_WelcomeWaitButton(helpListMenu, listMenuItemsBuffer); case 10: - return sub_812BCA8(a0, a1); + return HelpSystemSubroutine_WelcomeEndGotoMenu(helpListMenu, listMenuItemsBuffer); case 0: - return sub_812BCD0(a0, a1); + return HelpSystemSubroutine_MenuInputHandlerMain(helpListMenu, listMenuItemsBuffer); case 1: - return sub_812BD2C(a0, a1); + return HelpMenuSubroutine_InitSubmenu(helpListMenu, listMenuItemsBuffer); case 2: - return sub_812BD64(a0, a1); + return HelpMenuSubroutine_ReturnFromSubmenu(helpListMenu, listMenuItemsBuffer); case 3: - return sub_812BD98(a0, a1); + return HelpMenuSubroutine_SubmenuInputHandler(helpListMenu, listMenuItemsBuffer); case 4: - return sub_812BE10(a0, a1); + return HelpMenuSubroutine_HelpItemPrint(helpListMenu, listMenuItemsBuffer); case 5: - return sub_812BEEC(a0, a1); + return HelpMenuSubroutine_ReturnFromHelpItem(helpListMenu, listMenuItemsBuffer); case 6: - return sub_812BF18(a0, a1); + return HelpMenuSubroutine_HelpItemWaitButton(helpListMenu, listMenuItemsBuffer); } return FALSE; } -bool8 sub_812BC54(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpSystemSubroutine_PrintWelcomeMessage(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - sub_812BF74(gUnknown_841DFA5); - sub_812BF5C(); + PrintTextOnPanel2Row52RightAlign(gUnknown_841DFA5); + PrintWelcomeMessageOnPanel1(); sub_813BDA4(1); sub_813BD5C(1); - a0->field_0E = 9; + helpListMenu->state = 9; return TRUE; } -bool8 sub_812BC80(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpSystemSubroutine_WelcomeWaitButton(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { if (JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - a0->field_0E = 10; + helpListMenu->state = 10; } return TRUE; } -bool8 sub_812BCA8(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpSystemSubroutine_WelcomeEndGotoMenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - gUnknown_3005E9C[2] = 0; - sub_812BF94(a0); - sub_812B4D8(a0, a1); - a0->field_0E = 0; + sHelpSystemState[2] = 0; + ResetHelpSystemCursor(helpListMenu); + BuildAndPrintMainTopicsListMenu(helpListMenu, listMenuItemsBuffer); + helpListMenu->state = 0; return TRUE; } -bool8 sub_812BCD0(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpSystemSubroutine_MenuInputHandlerMain(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { s32 v0 = HelpSystem_GetMenuInput(); switch (v0) @@ -1425,42 +1424,42 @@ bool8 sub_812BCD0(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) return FALSE; case -5: case -4: - sub_812BF9C(a0, a1); + PrintHelpSystemTopicMouseoverDescription(helpListMenu, listMenuItemsBuffer); break; case -3: case -1: break; default: - gUnknown_3005E9C[1] = v0; - a0->field_0E = 1; + sHelpSystemState[1] = v0; + helpListMenu->state = 1; break; } return TRUE; } -bool8 sub_812BD2C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_InitSubmenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - gUnknown_3005E9C[0] = 1; - gUnknown_3005E9C[2] = a0->field_0D; - sub_812BF94(a0); - sub_812B5A8(a0, a1); + sHelpSystemState[0] = 1; + sHelpSystemState[2] = helpListMenu->cursorPos; + ResetHelpSystemCursor(helpListMenu); + BuildAndPrintSubmenuList(helpListMenu, listMenuItemsBuffer); sub_813C75C(); HelpSystem_SetInputDelay(2); - a0->field_0E = 3; + helpListMenu->state = 3; return TRUE; } -bool8 sub_812BD64(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_ReturnFromSubmenu(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { sub_813C004(0, 0); sub_813C004(1, 0); - gUnknown_3005E9C[0] = 0; - sub_812B4D8(a0, a1); - a0->field_0E = 0; + sHelpSystemState[0] = 0; + BuildAndPrintMainTopicsListMenu(helpListMenu, listMenuItemsBuffer); + helpListMenu->state = 0; return TRUE; } -bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_SubmenuInputHandler(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { s32 v0 = HelpSystem_GetMenuInput(); switch (v0) @@ -1468,7 +1467,7 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) case -6: return FALSE; case -2: - a0->field_0E = 2; + helpListMenu->state = 2; break; case -5: case -4: @@ -1476,8 +1475,8 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) case -1: break; default: - gUnknown_3005E9C[3] = v0; - a0->field_0E = 4; + sHelpSystemState[3] = v0; + helpListMenu->state = 4; break; } return TRUE; @@ -1485,60 +1484,60 @@ bool8 sub_812BD98(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) void sub_812BDEC(void) { - HelpSystem_PrintTextAt(gUnknown_845B080[gUnknown_3005E9C[1]], 0, 0); + HelpSystem_PrintTextAt(sHelpSystemTopicPtrs[sHelpSystemState[1]], 0, 0); } -bool8 sub_812BE10(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_HelpItemPrint(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - gUnknown_3005E9C[0] = 2; + sHelpSystemState[0] = 2; sub_813BDA4(0); HelpSystem_FillPanel1(); - sub_812BF74(gUnknown_841DFBE); + PrintTextOnPanel2Row52RightAlign(gUnknown_841DFBE); sub_813BDE8(1); sub_813BEE4(1); - if (gUnknown_3005E9C[1] == 0) + if (sHelpSystemState[1] == 0) { - HelpSystem_PrintTwoStrings(gUnknown_845B0B0[gUnknown_3005E9C[3]], gUnknown_845B164[gUnknown_3005E9C[3]]); + HelpSystem_PrintTwoStrings(sHelpSystemSpecializedQuestionTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedAnswerTextPtrs[sHelpSystemState[3]]); } - else if (gUnknown_3005E9C[1] == 1) + else if (sHelpSystemState[1] == 1) { - HelpSystem_PrintTwoStrings(gUnknown_845B218[gUnknown_3005E9C[3]], gUnknown_845B2DC[gUnknown_3005E9C[3]]); + HelpSystem_PrintTwoStrings(sHelpSystemMenuTopicTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedControlsTextPtrs[sHelpSystemState[3]]); } - else if (gUnknown_3005E9C[1] == 2) + else if (sHelpSystemState[1] == 2) { - HelpSystem_PrintTwoStrings(gUnknown_845B3A0[gUnknown_3005E9C[3]], gUnknown_845B450[gUnknown_3005E9C[3]]); + HelpSystem_PrintTwoStrings(sHelpSystemSpecializedStringsTextPtrs[sHelpSystemState[3]], sHelpSystemSpecializedStringDefinitionsTextPtrs[sHelpSystemState[3]]); } - else if (gUnknown_3005E9C[1] == 3) + else if (sHelpSystemState[1] == 3) { - HelpSystem_PrintTwoStrings(gUnknown_845B500[gUnknown_3005E9C[3]], gUnknown_845B520[gUnknown_3005E9C[3]]); + HelpSystem_PrintTwoStrings(sHelpSystemGeneralTopicTextPtrs[sHelpSystemState[3]], sHelpSystemGeneralTopicDescriptionTextPtrs[sHelpSystemState[3]]); } else { - HelpSystem_PrintTwoStrings(gUnknown_845B540[gUnknown_3005E9C[3]], gUnknown_845B5D0[gUnknown_3005E9C[3]]); + HelpSystem_PrintTwoStrings(sHelpSystemTypeMatchupTextPtrs[sHelpSystemState[3]], sHelpSystemTypeMatchupDescriptionTextPtrs[sHelpSystemState[3]]); } sub_813BDA4(1); sub_813BD5C(1); - a0->field_0E = 6; + helpListMenu->state = 6; return TRUE; } -bool8 sub_812BEEC(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_ReturnFromHelpItem(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - gUnknown_3005E9C[0] = 1; - sub_812B5A8(a0, a1); + sHelpSystemState[0] = 1; + BuildAndPrintSubmenuList(helpListMenu, listMenuItemsBuffer); sub_813C75C(); HelpSystem_SetInputDelay(2); - a0->field_0E = 3; + helpListMenu->state = 3; return TRUE; } -bool8 sub_812BF18(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +bool8 HelpMenuSubroutine_HelpItemWaitButton(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { if (JOY_NEW(B_BUTTON) || JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - a0->field_0E = 5; + helpListMenu->state = 5; return TRUE; } if (JOY_NEW(L_BUTTON | R_BUTTON)) @@ -1546,13 +1545,13 @@ bool8 sub_812BF18(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) return TRUE; } -static void sub_812BF5C(void) +static void PrintWelcomeMessageOnPanel1(void) { HelpSystem_FillPanel1(); HelpSystem_PrintTextAt(gUnknown_81B2FC9, 0, 0); } -static void sub_812BF74(const u8 * str) +static void PrintTextOnPanel2Row52RightAlign(const u8 * str) { HelpSystem_FillPanel2(); HelpSystem_PrintTextRightAlign_Row52(str); @@ -1560,21 +1559,21 @@ static void sub_812BF74(const u8 * str) u8 sub_812BF88(void) { - return gUnknown_3005E9C[0]; + return sHelpSystemState[0]; } -static void sub_812BF94(struct HelpSystemListMenu * a0) +static void ResetHelpSystemCursor(struct HelpSystemListMenu * helpListMenu) { - a0->field_0C = 0; - a0->field_0D = 0; + helpListMenu->itemsAbove = 0; + helpListMenu->cursorPos = 0; } -static void sub_812BF9C(struct HelpSystemListMenu * a0, struct ListMenuItem * a1) +static void PrintHelpSystemTopicMouseoverDescription(struct HelpSystemListMenu * helpListMenu, struct ListMenuItem * listMenuItemsBuffer) { - s32 index = a1[a0->field_0C + a0->field_0D].index; + s32 index = listMenuItemsBuffer[helpListMenu->itemsAbove + helpListMenu->cursorPos].index; if (index == -2) - HelpSystem_PrintText_813C584(gUnknown_845B098[5]); + HelpSystem_PrintText_813C584(sHelpSystemTopicMouseoverDescriptionPtrs[5]); else - HelpSystem_PrintText_813C584(gUnknown_845B098[index]); + HelpSystem_PrintText_813C584(sHelpSystemTopicMouseoverDescriptionPtrs[index]); sub_813BE30(1); } diff --git a/src/intro.c b/src/intro.c index cee1c8fec..837d4f905 100644 --- a/src/intro.c +++ b/src/intro.c @@ -1431,7 +1431,7 @@ static void sub_80EDB70(struct IntroSequenceData * this) { this->field_0018->pos1.x += this->field_0018->pos2.x; this->field_0018->pos1.y += this->field_0018->pos2.y; - sub_8007FFC(this->field_0018, 0, 0x2A); + obj_pos2_update_enable(this->field_0018, 0, 0x2A); this->field_0018->callback = SpriteCallbackDummy; StartSpriteAffineAnim(this->field_0018, 1); } @@ -1448,7 +1448,7 @@ static void sub_80EDBAC(struct IntroSequenceData * this) { StartSpriteAffineAnim(this->field_0028[i], 1); this->field_0028[i]->callback = nullsub_83; - sub_8007FFC(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]); + obj_pos2_update_enable(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]); } } diff --git a/src/learn_move.c b/src/learn_move.c index e22922528..8a2f5781b 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -309,7 +309,7 @@ static void MoveRelearnerLoadBgGfx(void) FillBgTilemapBufferRect(0, 0x000, 0, 0, 30, 20, 0xF); SetBgTilemapBuffer(1, sMoveRelearner->bg1TilemapBuffer); TextWindow_SetUserSelectedFrame(0, 1, 0xE0); - sub_8107D38(0xD0, 1); + ListMenuLoadStdPalAt(0xD0, 1); LoadPalette(gUnknown_8E97DDC, 0x00, 0x20); DecompressAndLoadBgGfxUsingHeap(1, gUnknown_8E97DFC, 0, 0, 0); CopyToBgTilemapBuffer(1, gUnknown_8E97EC4, 0, 0); diff --git a/src/librfu_intr.c b/src/librfu_intr.c new file mode 100644 index 000000000..23962a937 --- /dev/null +++ b/src/librfu_intr.c @@ -0,0 +1,402 @@ +#include "global.h" +#include "librfu.h" + +static void sio32intr_clock_master(void); +static void sio32intr_clock_slave(void); +static u16 handshake_wait(u16 slot); +static void STWI_set_timer_in_RAM(u8 count); +static void STWI_stop_timer_in_RAM(void); +static void STWI_init_slave(void); +static void Callback_Dummy_M(int reqCommandId, int error, void (*callbackM)()); +static void Callback_Dummy_S(u16 reqCommandId, void (*callbackS)(u16)); +static void Callback_Dummy_ID(void (*callbackId)(void)); + +void IntrSIO32(void) +{ + if (gSTWIStatus->state == 10) + { + if (gSTWIStatus->callbackID != NULL) + Callback_Dummy_ID(gSTWIStatus->callbackID); + } + else + { + if (gSTWIStatus->msMode == AGB_CLK_MASTER) + sio32intr_clock_master(); + else + sio32intr_clock_slave(); + } +} + +static void sio32intr_clock_master(void) +{ + u32 regSIODATA32; + u32 ackLen; + + STWI_set_timer_in_RAM(80); + regSIODATA32 = REG_SIODATA32; + + if (gSTWIStatus->state == 0) // master send req + { + if (regSIODATA32 == 0x80000000) + { + if (gSTWIStatus->reqNext <= gSTWIStatus->reqLength) + { + REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket->rfuPacket8.data)[gSTWIStatus->reqNext]; + gSTWIStatus->reqNext++; + } + else + { + gSTWIStatus->state = 1; // master wait ack + REG_SIODATA32 = 0x80000000; + } + } + else + { + STWI_stop_timer_in_RAM(); + STWI_set_timer_in_RAM(130); + return; + } + } + else if (gSTWIStatus->state == 1) // master wait ack + { + if ((regSIODATA32 & 0xFFFF0000) == 0x99660000) + { + gSTWIStatus->ackNext = 0; + ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->ackNext] = regSIODATA32; + gSTWIStatus->ackNext++; + gSTWIStatus->ackActiveCommand = regSIODATA32; + gSTWIStatus->ackLength = ackLen = regSIODATA32 >> 8; + if ((ackLen = gSTWIStatus->ackLength) >= gSTWIStatus->ackNext) + { + gSTWIStatus->state = 2; // master receive ack + REG_SIODATA32 = 0x80000000; + } + else + { + gSTWIStatus->state = 3; // master done ack + } + } + else + { + STWI_stop_timer_in_RAM(); + STWI_set_timer_in_RAM(130); + return; + } + } + else if (gSTWIStatus->state == 2) // master receive ack + { + ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->ackNext] = regSIODATA32; + gSTWIStatus->ackNext++; + if (gSTWIStatus->ackLength < gSTWIStatus->ackNext) + gSTWIStatus->state = 3; // master done ack + else + REG_SIODATA32 = 0x80000000; + } + + if (handshake_wait(1) == 1) + return; + + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS | SIO_MULTI_SD; + + if (handshake_wait(0) == 1) + return; + + STWI_stop_timer_in_RAM(); + + if (gSTWIStatus->state == 3) // master done ack + { + if ( + gSTWIStatus->ackActiveCommand == (0x80 | ID_MS_CHANGE_REQ) + || gSTWIStatus->ackActiveCommand == (0x80 | ID_DATA_TX_AND_CHANGE_REQ) + || gSTWIStatus->ackActiveCommand == (0x80 | ID_UNK35_REQ) + || gSTWIStatus->ackActiveCommand == (0x80 | ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) + ) + { + + gSTWIStatus->msMode = AGB_CLK_SLAVE; + REG_SIODATA32 = 0x80000000; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE; + gSTWIStatus->state = 5; // slave receive req init + } + else + { + if (gSTWIStatus->ackActiveCommand == 0xEE) + { + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + gSTWIStatus->state = 4; // error + gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION; + } + else + { + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + gSTWIStatus->state = 4; // error + } + } + gSTWIStatus->sending = 0; + if (gSTWIStatus->callbackM != NULL) + Callback_Dummy_M(gSTWIStatus->reqActiveCommand, gSTWIStatus->error, gSTWIStatus->callbackM); + } + else + { + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS | SIO_ENABLE; + } +} + +static void sio32intr_clock_slave(void) +{ + u32 regSIODATA32; + u32 r0; + register u32 reqLen asm("r2"); + + gSTWIStatus->timerActive = 0; + STWI_set_timer_in_RAM(100); + if (handshake_wait(0) == 1) + return; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_MULTI_SD; + regSIODATA32 = REG_SIODATA32; + if (gSTWIStatus->state == 5) // slave receive req init + { + ((u32*)gSTWIStatus->rxPacket)[0] = regSIODATA32; + gSTWIStatus->reqNext = 1; + r0 = 0x99660000; + if ((regSIODATA32 >> 16) == (r0 >> 16)) + { + gSTWIStatus->reqLength = reqLen = regSIODATA32 >> 8; + gSTWIStatus->reqActiveCommand = regSIODATA32; + if (gSTWIStatus->reqLength == 0) + { + if ( + gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_DATA_READY_AND_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_DISCONNECTED_AND_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_UNK36_REQ + ) + { + gSTWIStatus->ackActiveCommand = gSTWIStatus->reqActiveCommand + 0x80; + ((u32*)gSTWIStatus->txPacket)[0] = 0x99660000 + gSTWIStatus->ackActiveCommand; + gSTWIStatus->ackLength = 0; + } + else + { + ((u32*)gSTWIStatus->txPacket)[0] = 0x996601EE; + if (gSTWIStatus->reqActiveCommand >= 0x10 && gSTWIStatus->reqActiveCommand <= 0x3D) + { + ((u32*)gSTWIStatus->txPacket)[1] = 1; + } + else + { + ((u32*)gSTWIStatus->txPacket)[1] = 2; + } + gSTWIStatus->ackLength = 1; + gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION; + } + REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[0]; + gSTWIStatus->ackNext = 1; + gSTWIStatus->state = 7; // slave send ack + } + else + { + REG_SIODATA32 = 0x80000000; + gSTWIStatus->reqNext = 1; + gSTWIStatus->state = 6; // slave receive req + } + } + else + { + STWI_stop_timer_in_RAM(); + STWI_set_timer_in_RAM(100); + return; + } + } + else if (gSTWIStatus->state == 6) // slave receive req + { + ((u32*)gSTWIStatus->rxPacket)[gSTWIStatus->reqNext] = regSIODATA32; + gSTWIStatus->reqNext++; + if (gSTWIStatus->reqLength < gSTWIStatus->reqNext) + { + if ( + gSTWIStatus->reqActiveCommand == ID_DATA_READY_AND_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_DISCONNECTED_AND_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_UNK36_REQ + ) + { + gSTWIStatus->ackActiveCommand = gSTWIStatus->reqActiveCommand + 0x80; + ((u32*)gSTWIStatus->txPacket)[0] = 0x99660000 | gSTWIStatus->ackActiveCommand; + gSTWIStatus->ackLength = 0; + } + else + { + ((u32*)gSTWIStatus->txPacket)[0] = 0x996601EE; + if (gSTWIStatus->reqActiveCommand >= 0x10 && gSTWIStatus->reqActiveCommand <= 0x3D) + { + ((u32*)gSTWIStatus->txPacket)[1] = 1; + } + else + { + ((u32*)gSTWIStatus->txPacket)[1] = 2; + } + gSTWIStatus->ackLength = 1; + gSTWIStatus->error = ERR_REQ_CMD_ACK_REJECTION; + } + REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[0]; + gSTWIStatus->ackNext = 1; + gSTWIStatus->state = 7; // slave send ack + } + else + { + REG_SIODATA32 = 0x80000000; + } + } + else if (gSTWIStatus->state == 7) // slave send ack + { + if (regSIODATA32 == 0x80000000) + { + if (gSTWIStatus->ackLength < gSTWIStatus->ackNext) + { + gSTWIStatus->state = 8; // slave done ack + } + else + { + REG_SIODATA32 = ((u32*)gSTWIStatus->txPacket)[gSTWIStatus->ackNext]; + gSTWIStatus->ackNext++; + } + } + else + { + STWI_stop_timer_in_RAM(); + STWI_set_timer_in_RAM(100); + return; + } + } + if (handshake_wait(1) == 1) + return; + if (gSTWIStatus->state == 8) // slave done ack + { + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS; + STWI_stop_timer_in_RAM(); + if (gSTWIStatus->error == ERR_REQ_CMD_ACK_REJECTION) + { + STWI_init_slave(); + if (gSTWIStatus->callbackS != NULL) + { + Callback_Dummy_S(0x1EE, gSTWIStatus->callbackS); + } + } + else + { + REG_SIODATA32 = 0; + REG_SIOCNT = 0; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + gSTWIStatus->msMode = AGB_CLK_MASTER; + gSTWIStatus->state = 0; // master send req + if (gSTWIStatus->callbackS != NULL) + { + Callback_Dummy_S((gSTWIStatus->reqLength << 8) | (gSTWIStatus->reqActiveCommand), gSTWIStatus->callbackS); + } + } + } + else + { + REG_IME = 0; + if (REG_TM0CNT_H & TIMER_ENABLE) + { + if ((REG_TM0CNT_H & 0x03) == TIMER_1CLK) + { + while (REG_TM0CNT_L > 0xFF9B); + } + else + { + while (REG_TM0CNT_L > 0xFFFE); + } + } + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE; + REG_IME = 1; + } +} + +static u16 handshake_wait(u16 slot) +{ + do + { + if ((gSTWIStatus->timerActive & 0xFF) == 1) + { + gSTWIStatus->timerActive = 0; + return 1; + } + } while ((REG_SIOCNT & SIO_MULTI_SI) != (slot << SIO_MULTI_SI_SHIFT)); + return 0; +} + +static void STWI_set_timer_in_RAM(u8 count) +{ + vu16* regTMCNTL = (vu16*)(REG_ADDR_TMCNT_L + gSTWIStatus->timerSelect * 4); + vu16* regTMCNTH = (vu16*)(REG_ADDR_TMCNT_H + gSTWIStatus->timerSelect * 4); + REG_IME = 0; + switch (count) + { + case 50: + *regTMCNTL = 0xFCCB; + gSTWIStatus->timerState = 1; + break; + case 80: + *regTMCNTL = 0xFAE0; + gSTWIStatus->timerState = 2; + break; + case 100: + *regTMCNTL = 0xF996; + gSTWIStatus->timerState = 3; + break; + case 130: + *regTMCNTL = 0xF7AD; + gSTWIStatus->timerState = 4; + break; + } + *regTMCNTH = TIMER_ENABLE | TIMER_64CLK | TIMER_256CLK | TIMER_INTR_ENABLE; + REG_IF = INTR_FLAG_TIMER0 << gSTWIStatus->timerSelect; + REG_IME = 1; +} + +static void STWI_stop_timer_in_RAM(void) +{ + gSTWIStatus->timerState = 0; + REG_TMCNT_L(gSTWIStatus->timerSelect) = 0; + REG_TMCNT_H(gSTWIStatus->timerSelect) = 0; +} + +static void STWI_init_slave(void) +{ + gSTWIStatus->state = 5; // slave receive req init + gSTWIStatus->msMode = AGB_CLK_SLAVE; + gSTWIStatus->reqLength = 0; + gSTWIStatus->reqNext = 0; + gSTWIStatus->reqActiveCommand = 0; + gSTWIStatus->ackLength = 0; + gSTWIStatus->ackNext = 0; + gSTWIStatus->ackActiveCommand = 0; + gSTWIStatus->timerState = 0; + gSTWIStatus->timerActive = 0; + gSTWIStatus->error = 0; + gSTWIStatus->recoveryCount = 0; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_57600_BPS | SIO_ENABLE; +} + +NAKED +static void Callback_Dummy_M(int reqCommandId, int error, void (*callbackM)()) +{ + asm("bx r2"); +} + +NAKED +static void Callback_Dummy_S(u16 reqCommandId, void (*callbackS)(u16)) +{ + asm("bx r1"); +} + +NAKED +static void Callback_Dummy_ID(void (*callbackId)(void)) +{ + asm("bx r0"); +} diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index dccd342f2..420fb7c9a 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -2,54 +2,54 @@ struct LLSFStruct { - u8 unk00; - u8 unk01; - u8 unk02; - u8 unk03; - u8 unk04; - u8 unk05; - u8 unk06; - u8 unk07; - u8 unk08; - u8 unk09; - u8 unk0A; - u8 unk0B; - u8 unk0C; - u16 unk0E; + u8 frameSize; + u8 recvFirstShift; + u8 connSlotFlagShift; + u8 slotStateShift; + u8 ackShift; + u8 phaseShit; + u8 nShift; + u8 recvFirstMask; + u8 connSlotFlagMask; + u8 slotStateMask; + u8 ackMask; + u8 phaseMask; + u8 nMask; + u16 framesMask; }; struct RfuLocalStruct { - u8 unk00; - u8 unk01; - u8 unk02; - u8 unk03; - u8 unk04; - u8 unk05; - u16 unk06; + u8 recvFirst; + u8 connSlotFlag; + u8 slotState; + u8 ack; + u8 phase; + u8 n; + u16 frame; }; -static void rfu_CB_defaultCallback(u8, u16); -static void rfu_CB_reset(u8, u16); -static void rfu_CB_configGameData(u8, u16); -static void rfu_CB_stopMode(u8, u16); -static void rfu_CB_startSearchChild(u8, u16); -static void rfu_CB_pollAndEndSearchChild(u8, u16); -static void rfu_CB_startSearchParent(u8, u16); -static void rfu_CB_pollSearchParent(u8, u16); -static void rfu_CB_pollConnectParent(u8, u16); -static void rfu_CB_pollConnectParent(u8, u16); -static void rfu_CB_disconnect(u8, u16); -static void rfu_CB_CHILD_pollConnectRecovery(u8, u16); -static void rfu_CB_sendData(UNUSED u8, u16); -static void rfu_CB_sendData2(UNUSED u8, u16); -static void rfu_CB_sendData3(u8, u16); -static void rfu_CB_recvData(u8, u16); -static void rfu_enableREQCallback(bool8); +static void rfu_CB_defaultCallback(u8 reqCommand, u16 reqResult); +static void rfu_CB_reset(u8 reqCommand, u16 reqResult); +static void rfu_CB_configGameData(u8 reqCommand, u16 reqResult); +static void rfu_CB_stopMode(u8 reqCommand, u16 reqResult); +static void rfu_CB_startSearchChild(u8 reqCommand, u16 reqResult); +static void rfu_CB_pollAndEndSearchChild(u8 reqCommand, u16 reqResult); +static void rfu_CB_startSearchParent(u8 reqCommand, u16 reqResult); +static void rfu_CB_pollSearchParent(u8 reqCommand, u16 reqResult); +static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult); +static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult); +static void rfu_CB_disconnect(u8 reqCommand, u16 reqResult); +static void rfu_CB_CHILD_pollConnectRecovery(u8 reqCommand, u16 reqResult); +static void rfu_CB_sendData(UNUSED u8 reqCommand, u16 reqResult); +static void rfu_CB_sendData2(UNUSED u8 reqCommand, u16 reqResult); +static void rfu_CB_sendData3(u8 reqCommand, u16 reqResult); +static void rfu_CB_recvData(u8 reqCommand, u16 reqResult); +static void rfu_enableREQCallback(bool8 enable); static void rfu_STC_clearAPIVariables(void); static void rfu_STC_readChildList(void); static void rfu_STC_readParentCandidateList(void); -static void rfu_STC_REQ_callback(u8, u16); +static void rfu_STC_REQ_callback(u8 reqCommand, u16 reqResult); static void rfu_STC_removeLinkData(u8, u8); static void rfu_STC_fastCopy(const u8 **, u8 **, s32); static void rfu_STC_clearLinkStatus(u8); @@ -74,13 +74,38 @@ struct RfuStatic *gRfuStatic; struct RfuFixed *gRfuFixed; static const struct LLSFStruct llsf_struct[2] = { - { - 2, 14, 0, 10, 9, 5, 7, 2, - 0, 15, 1, 3, 3, 0x1f - }, { - 3, 22, 18, 14, 13, 9, 11, 3, - 15, 15, 1, 3, 3, 0x7f - } + [MODE_CHILD] = { + .frameSize = 2, + .recvFirstShift = 14, + .connSlotFlagShift = 0, + .slotStateShift = 10, + .ackShift = 9, + .phaseShit = 5, + .nShift = 7, + .recvFirstMask = 2, + .connSlotFlagMask = 0, + .slotStateMask = 15, + .ackMask = 1, + .phaseMask = 3, + .nMask = 3, + .framesMask = 0x1f + }, + [MODE_PARENT] = { + .frameSize = 3, + .recvFirstShift = 22, + .connSlotFlagShift = 18, + .slotStateShift = 14, + .ackShift = 13, + .phaseShit = 9, + .nShift = 11, + .recvFirstMask = 3, + .connSlotFlagMask = 15, + .slotStateMask = 15, + .ackMask = 1, + .phaseMask = 3, + .nMask = 3, + .framesMask = 0x7f + } }; #ifdef EMERALD @@ -91,46 +116,54 @@ static const char lib_ver[] = "RFU_V1024"; static const char str_checkMbootLL[] = "RFU-MBOOT"; -u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) +#define COPY(src, dst, size) do { \ + const u16 *_src = (const u16 *)(src); \ + u16 *_dst = (u16 *)(dst); \ + u16 _size = (size); \ + while (_size-- != 0) \ + *_dst++ = *_src++; \ +} while (0) + +u16 rfu_initializeAPI(u32 *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) { u16 i; u16 *dst; const u16 *src; - u16 r3; + u16 buffByteSizeMax; - // is in EWRAM? - if (((u32)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam) + // is in EWRAM? + if (((uintptr_t)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam) return ERR_RFU_API_BUFF_ADR; - // is not 4-byte aligned? + // is not 4-byte aligned? if ((u32)APIBuffer & 3) return ERR_RFU_API_BUFF_ADR; if (copyInterruptToRam) { // An assert/debug print may have existed before, ie // printf("%s %u < %u", "somefile.c:12345", buffByteSize, num) - // to push this into r3? - r3 = sizeof(struct RfuAPIBuffer); - if (buffByteSize < r3) + // to push this into buffByteSizeMax? + buffByteSizeMax = RFU_API_BUFF_SIZE_RAM; + if (buffByteSize < buffByteSizeMax) return ERR_RFU_API_BUFF_SIZE; } if (!copyInterruptToRam) { - r3 = 0x504; // same issue as above - if (buffByteSize < r3) + buffByteSizeMax = RFU_API_BUFF_SIZE_ROM; // same issue as above + if (buffByteSize < buffByteSizeMax) return ERR_RFU_API_BUFF_SIZE; } - gRfuLinkStatus = &APIBuffer->linkStatus; - gRfuStatic = &APIBuffer->static_; - gRfuFixed = &APIBuffer->fixed; - gRfuSlotStatusNI[0] = &APIBuffer->NI[0]; - gRfuSlotStatusUNI[0] = &APIBuffer->UNI[0]; + gRfuLinkStatus = (void *)APIBuffer + 0; + gRfuStatic = (void *)APIBuffer + 0xb4; // + sizeof(*gRfuLinkStatus) + gRfuFixed = (void *)APIBuffer + 0xdc; // + sizeof(*gRfuStatic) + gRfuSlotStatusNI[0] = (void *)APIBuffer + 0x1bc; // + sizeof(*gRfuFixed) + gRfuSlotStatusUNI[0] = (void *)APIBuffer + 0x37c; // + sizeof(*gRfuSlotStatusNI[0]) for (i = 1; i < RFU_CHILD_MAX; ++i) { gRfuSlotStatusNI[i] = &gRfuSlotStatusNI[i - 1][1]; gRfuSlotStatusUNI[i] = &gRfuSlotStatusUNI[i - 1][1]; } - // TODO: Is it possible to fix the following 2 statements? - // It's equivalent to: + // TODO: Is it possible to fix the following 2 statements? + // It's equivalent to: // gRfuFixed->STWIBuffer = &APIBuffer->intr; // STWI_init_all(&APIBuffer->intr, sioIntrTable_p, copyInterruptToRam); gRfuFixed->STWIBuffer = (struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1]; @@ -143,11 +176,21 @@ u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc gRfuSlotStatusUNI[i]->recvBuffer = NULL; gRfuSlotStatusUNI[i]->recvBufferSize = 0; } - src = (const u16 *)((u32)&rfu_STC_fastCopy & ~1); - dst = gRfuFixed->fastCopyBuffer; // rfu_REQ_changeMasterSlave is the function next to rfu_STC_fastCopy - for (r3 = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16), --r3; r3 != 0xFFFF; --r3) +#if LIBRFU_VERSION < 1028 + src = (const u16 *)((uintptr_t)&rfu_STC_fastCopy & ~1); + dst = gRfuFixed->fastCopyBuffer; + buffByteSizeMax = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16); + while (buffByteSizeMax-- != 0) *dst++ = *src++; +#else + // register swap dst <--> buffByteSizeMax + COPY( + (const u16 *)((uintptr_t)&rfu_STC_fastCopy & ~1), + gRfuFixed->fastCopyBuffer, + 0x60 / sizeof(u16) + ); +#endif gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1; return 0; } @@ -155,19 +198,19 @@ u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc static void rfu_STC_clearAPIVariables(void) { u16 IMEBackup = REG_IME; - u8 i, r4; + u8 i, flags; REG_IME = 0; - r4 = gRfuStatic->flags; + flags = gRfuStatic->flags; CpuFill16(0, gRfuStatic, sizeof(struct RfuStatic)); - gRfuStatic->flags = r4 & 8; + gRfuStatic->flags = flags & 8; CpuFill16(0, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); gRfuLinkStatus->watchInterval = 4; gRfuStatic->nowWatchInterval = 0; gRfuLinkStatus->parentChild = MODE_NEUTRAL; rfu_clearAllSlot(); gRfuStatic->SCStartFlag = 0; - for (i = 0; i < NELEMS(gRfuStatic->cidBak); ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) gRfuStatic->cidBak[i] = 0; REG_IME = IMEBackup; } @@ -180,20 +223,20 @@ void rfu_REQ_PARENT_resumeRetransmitAndChange(void) u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) { - struct RfuIntrStruct *buf; + u8 *buf; *ackFlag = 0; if (gRfuLinkStatus->parentChild != MODE_PARENT) return ERR_MODE_NOT_PARENT; buf = rfu_getSTWIRecvBuffer(); - switch (buf->rxPacketAlloc.rfuPacket8.data[0]) + switch (*buf) { case 40: case 54: - if (buf->rxPacketAlloc.rfuPacket8.data[1] == 0) + if (buf[1] == 0) *ackFlag = gRfuLinkStatus->connSlotFlag; else - *ackFlag = buf->rxPacketAlloc.rfuPacket8.data[4]; + *ackFlag = buf[4]; return 0; default: return ERR_REQ_CMD_ID; @@ -205,9 +248,9 @@ void rfu_setTimerInterrupt(u8 timerNo, IntrFunc *timerIntrTable_p) STWI_init_timer(timerIntrTable_p, timerNo); } -struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void) +u8 *rfu_getSTWIRecvBuffer(void) { - return gRfuFixed->STWIBuffer; + return (u8 *)gRfuFixed->STWIBuffer; } void rfu_setMSCCallback(void (*callback)(u16 reqCommandId)) @@ -229,26 +272,26 @@ static void rfu_enableREQCallback(bool8 enable) gRfuStatic->flags &= 0xF7; } -static void rfu_STC_REQ_callback(u8 r5, u16 reqResult) +static void rfu_STC_REQ_callback(u8 reqCommand, u16 reqResult) { STWI_set_Callback_M(rfu_CB_defaultCallback); gRfuStatic->reqResult = reqResult; if (gRfuStatic->flags & 8) - gRfuFixed->reqCallback(r5, reqResult); + gRfuFixed->reqCallback(reqCommand, reqResult); } -static void rfu_CB_defaultCallback(u8 r0, u16 reqResult) +static void rfu_CB_defaultCallback(u8 reqCommand, u16 reqResult) { - s32 r5; + s32 bmSlotFlags; u8 i; - if (r0 == 0xFF) + if (reqCommand == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ) { if (gRfuStatic->flags & 8) - gRfuFixed->reqCallback(r0, reqResult); - r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + gRfuFixed->reqCallback(reqCommand, reqResult); + bmSlotFlags = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; for (i = 0; i < RFU_CHILD_MAX; ++i) - if ((r5 >> i) & 1) + if ((bmSlotFlags >> i) & 1) rfu_STC_removeLinkData(i, 1); gRfuLinkStatus->parentChild = MODE_NEUTRAL; } @@ -277,25 +320,39 @@ u16 rfu_getRFUStatus(u8 *rfuState) return 0; } +/* + * RFU Multiboot images are loaded into IWRAM + * struct RfuMbootLL + * { + * struct RfuLinkStatus status; + * u8 filler_B4[0x3C]; + * char name[10]; + * u16 checksum; + * } + * Returns 1 if the packet to inherit is malformed. + */ u16 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) { const char *s1 = str_checkMbootLL; char *s2 = (char *)0x30000F0; u16 checksum; - u16 *r2; + u16 *mb_buff_iwram_p; u8 i; + // if (strcmp(s1, s2) != 0) return 1; while (*s1 != '\0') if (*s1++ != *s2++) return 1; - r2 = (u16 *)0x3000000; + mb_buff_iwram_p = (u16 *)0x3000000; + + // The size of struct RfuLinkStatus is 180 checksum = 0; - for (i = 0; i < 90; ++i) - checksum += *r2++; + for (i = 0; i < 180/2; ++i) + checksum += *mb_buff_iwram_p++; if (checksum != *(u16 *)0x30000FA) return 1; CpuCopy16((u16 *)0x3000000, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); - gRfuStatic->flags |= 0x80; + gRfuStatic->flags |= 0x80; // mboot return 0; } @@ -305,14 +362,14 @@ void rfu_REQ_stopMode(void) if (REG_IME == 0) { - rfu_STC_REQ_callback(61, 6); + rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 6); gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE; } else { AgbRFU_SoftReset(); rfu_STC_clearAPIVariables(); - if (AgbRFU_checkID(8) == 0x8001) + if (AgbRFU_checkID(8) == RFU_ID) { timerReg = ®_TMCNT(gSTWIStatus->timerSelect); *timerReg = 0; @@ -326,29 +383,29 @@ void rfu_REQ_stopMode(void) else { REG_SIOCNT = SIO_MULTI_MODE; - rfu_STC_REQ_callback(61, 0); + rfu_STC_REQ_callback(ID_STOP_MODE_REQ, 0); } } } -static void rfu_CB_stopMode(u8 a1, u16 reqResult) +static void rfu_CB_stopMode(u8 reqCommand, u16 reqResult) { if (reqResult == 0) REG_SIOCNT = SIO_MULTI_MODE; - rfu_STC_REQ_callback(a1, reqResult); + rfu_STC_REQ_callback(reqCommand, reqResult); } u32 rfu_REQBN_softReset_and_checkID(void) { - u32 r2; + u32 id; if (REG_IME == 0) return ERR_ID_CHECK_IME_DISABLE; AgbRFU_SoftReset(); rfu_STC_clearAPIVariables(); - if ((r2 = AgbRFU_checkID(30)) == 0) + if ((id = AgbRFU_checkID(30)) == 0) REG_SIOCNT = SIO_MULTI_MODE; - return r2; + return id; } void rfu_REQ_reset(void) @@ -357,11 +414,11 @@ void rfu_REQ_reset(void) STWI_send_ResetREQ(); } -static void rfu_CB_reset(u8 a1, u16 reqResult) +static void rfu_CB_reset(u8 reqCommand, u16 reqResult) { if (reqResult == 0) rfu_STC_clearAPIVariables(); - rfu_STC_REQ_callback(a1, reqResult); + rfu_STC_REQ_callback(reqCommand, reqResult); } void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer) @@ -370,59 +427,59 @@ void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer) STWI_send_SystemConfigREQ((availSlotFlag & AVAIL_SLOT1) | 0x3C, maxMFrame, mcTimer); if (mcTimer == 0) { - gRfuStatic->unk_1a = 1; + gRfuStatic->linkEmergencyLimit = 1; } else { u16 IMEBackup = REG_IME; REG_IME = 0; - gRfuStatic->unk_1a = Div(600, mcTimer); + gRfuStatic->linkEmergencyLimit = Div(600, mcTimer); REG_IME = IMEBackup; } } void rfu_REQ_configGameData(u8 mbootFlag, u16 serialNo, const u8 *gname, const u8 *uname) { - u8 sp[16]; + u8 packet[16]; u8 i; - u8 r3; + u8 check_sum; const u8 *gnameBackup = gname; const u8 *unameBackup; - sp[0] = serialNo; - sp[1] = serialNo >> 8; + packet[0] = serialNo; + packet[1] = serialNo >> 8; if (mbootFlag != 0) - sp[1] = (serialNo >> 8) | 0x80; + packet[1] = (serialNo >> 8) | 0x80; for (i = 2; i < 15; ++i) - sp[i] = *gname++; - r3 = 0; + packet[i] = *gname++; + check_sum = 0; unameBackup = uname; for (i = 0; i < 8; ++i) { - r3 += *unameBackup++; - r3 += *gnameBackup++; + check_sum += *unameBackup++; + check_sum += *gnameBackup++; } - sp[15] = ~r3; + packet[15] = ~check_sum; if (mbootFlag != 0) - sp[14] = 0; + packet[14] = 0; STWI_set_Callback_M(rfu_CB_configGameData); - STWI_send_GameConfigREQ(sp, uname); + STWI_send_GameConfigREQ(packet, uname); } -static void rfu_CB_configGameData(u8 ip, u16 r7) +static void rfu_CB_configGameData(u8 reqCommand, u16 reqResult) { - s32 r2, r3; - u8 *r4; + s32 serialNo; + u8 *gname_uname_p; u8 i; - u8 *r1; + u8 *packet_p; - if (r7 == 0) + if (reqResult == 0) { - r1 = gSTWIStatus->txPacket->rfuPacket8.data; - r2 = gRfuLinkStatus->my.serialNo = r1[4]; - gRfuLinkStatus->my.serialNo = (r1[5] << 8) | r2; - r4 = &r1[6]; + packet_p = gSTWIStatus->txPacket->rfuPacket8.data; + serialNo = gRfuLinkStatus->my.serialNo = packet_p[4]; + gRfuLinkStatus->my.serialNo = (packet_p[5] << 8) | serialNo; + gname_uname_p = &packet_p[6]; if (gRfuLinkStatus->my.serialNo & 0x8000) { gRfuLinkStatus->my.serialNo = gRfuLinkStatus->my.serialNo ^ 0x8000; @@ -433,47 +490,54 @@ static void rfu_CB_configGameData(u8 ip, u16 r7) gRfuLinkStatus->my.mbootFlag = 0; } for (i = 0; i < RFU_GAME_NAME_LENGTH; ++i) - gRfuLinkStatus->my.gname[i] = *r4++; - ++r4; + gRfuLinkStatus->my.gname[i] = *gname_uname_p++; + ++gname_uname_p; for (i = 0; i < RFU_USER_NAME_LENGTH; ++i) - gRfuLinkStatus->my.uname[i] = *r4++; + gRfuLinkStatus->my.uname[i] = *gname_uname_p++; } - rfu_STC_REQ_callback(ip, r7); + rfu_STC_REQ_callback(reqCommand, reqResult); } void rfu_REQ_startSearchChild(void) { - u16 r1; - + u16 result; +#if LIBRFU_VERSION >= 1028 + u16 i; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + gRfuStatic->lsFixedCount[i] = 0; + } +#endif + STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_SystemStatusREQ(); - r1 = STWI_poll_CommandEnd(); - if (r1 == 0) + result = STWI_poll_CommandEnd(); + if (result == 0) { if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) - rfu_STC_clearLinkStatus(1); + rfu_STC_clearLinkStatus(MODE_PARENT); } else { - rfu_STC_REQ_callback(25, r1); + rfu_STC_REQ_callback(ID_SC_START_REQ, result); } STWI_set_Callback_M(rfu_CB_startSearchChild); STWI_send_SC_StartREQ(); } -static void rfu_CB_startSearchChild(u8 r3, u16 reqResult) +static void rfu_CB_startSearchChild(u8 reqCommand, u16 reqResult) { if (reqResult == 0) gRfuStatic->SCStartFlag = 1; - rfu_STC_REQ_callback(r3, reqResult); + rfu_STC_REQ_callback(reqCommand, reqResult); } -static void rfu_STC_clearLinkStatus(u8 r4) +static void rfu_STC_clearLinkStatus(u8 parentChild) { u8 i; - + rfu_clearAllSlot(); - if (r4 != 0) + if (parentChild != MODE_CHILD) { CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); gRfuLinkStatus->findParentCount = 0; @@ -498,11 +562,11 @@ void rfu_REQ_endSearchChild(void) STWI_send_SC_EndREQ(); } -static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) +static void rfu_CB_pollAndEndSearchChild(u8 reqCommand, u16 reqResult) { if (reqResult == 0) rfu_STC_readChildList(); - if (r4 == 26) + if (reqCommand == ID_SC_POLL_REQ) { if (gRfuLinkStatus->my.id == 0) { @@ -512,60 +576,65 @@ static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) gRfuLinkStatus->my.id = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; } } - else if (r4 == 27) + else if (reqCommand == ID_SC_END_REQ) { if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) gRfuLinkStatus->my.id = 0; gRfuStatic->SCStartFlag = 0; } - rfu_STC_REQ_callback(r4, reqResult); + rfu_STC_REQ_callback(reqCommand, reqResult); } static void rfu_STC_readChildList(void) { - u32 r5; - u8 r8 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]; - u8 *r4; + u32 stwiParam; + u8 numSlots = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]; + u8 *data_p; u8 i; - u8 sp[4]; - u8 r2; + u8 true_slots[RFU_CHILD_MAX]; + u8 bm_slot_id; + +#if LIBRFU_VERSION >= 1028 +//#if 1 + // TODO: decompile this +#endif - if (r8 != 0) + if (numSlots != 0) { - r5 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_LinkStatusREQ(); if (STWI_poll_CommandEnd() == 0) { - r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; - for (i = 0; i < NELEMS(sp); ++i) - sp[i] = *r4++; + data_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + for (i = 0; i < RFU_CHILD_MAX; ++i) + true_slots[i] = *data_p++; } - gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = r5; + gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = stwiParam; } - for (r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; - r8 != 0; - r4 += 4) + for (data_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + numSlots != 0; + data_p += 4) { - r2 = r4[2]; - if (r2 < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1)) + bm_slot_id = data_p[2]; + if (bm_slot_id < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> bm_slot_id) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> bm_slot_id) & 1)) { - if (sp[r2] != 0) - ++gRfuStatic->lsFixedCount[r2]; - if (gRfuStatic->lsFixedCount[r2] >= 4) + if (true_slots[bm_slot_id] != 0) + ++gRfuStatic->lsFixedCount[bm_slot_id]; + if (gRfuStatic->lsFixedCount[bm_slot_id] >= 4) { - gRfuStatic->lsFixedCount[r2] = 0; - gRfuLinkStatus->strength[r2] = 0xFF; - gRfuLinkStatus->connSlotFlag |= 1 << r2; + gRfuStatic->lsFixedCount[bm_slot_id] = 0; + gRfuLinkStatus->strength[bm_slot_id] = 255; + gRfuLinkStatus->connSlotFlag |= 1 << bm_slot_id; ++gRfuLinkStatus->connCount; - gRfuLinkStatus->partner[r2].id = *(u16 *)r4; - gRfuLinkStatus->partner[r2].slot = r2; + gRfuLinkStatus->partner[bm_slot_id].id = *(u16 *)data_p; + gRfuLinkStatus->partner[bm_slot_id].slot = bm_slot_id; gRfuLinkStatus->parentChild = MODE_PARENT; gRfuStatic->flags &= 0x7F; - gRfuStatic->cidBak[r2] = gRfuLinkStatus->partner[r2].id; + gRfuStatic->cidBak[bm_slot_id] = gRfuLinkStatus->partner[bm_slot_id].id; } } - --r8; + --numSlots; } } @@ -575,11 +644,11 @@ void rfu_REQ_startSearchParent(void) STWI_send_SP_StartREQ(); } -static void rfu_CB_startSearchParent(u8 r5, u16 reqResult) +static void rfu_CB_startSearchParent(u8 reqCommand, u16 reqResult) { if (reqResult == 0) - rfu_STC_clearLinkStatus(0); - rfu_STC_REQ_callback(r5, reqResult); + rfu_STC_clearLinkStatus(MODE_CHILD); + rfu_STC_REQ_callback(reqCommand, reqResult); } void rfu_REQ_pollSearchParent(void) @@ -588,11 +657,11 @@ void rfu_REQ_pollSearchParent(void) STWI_send_SP_PollingREQ(); } -static void rfu_CB_pollSearchParent(u8 r5, u16 reqResult) +static void rfu_CB_pollSearchParent(u8 reqCommand, u16 reqResult) { if (reqResult == 0) rfu_STC_readParentCandidateList(); - rfu_STC_REQ_callback(r5, reqResult); + rfu_STC_REQ_callback(reqCommand, reqResult); } void rfu_REQ_endSearchParent(void) @@ -603,47 +672,47 @@ void rfu_REQ_endSearchParent(void) static void rfu_STC_readParentCandidateList(void) { - u8 r7, r6, r5, r4, r3; - u8 *r1, *r2; - struct RfuTgtData *r4_; + u8 numSlots, i, check_sum, my_check_sum, j; + u8 *uname_p, *packet_p; + struct RfuTgtData *target; CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); - r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0]; - r7 = r2[1]; - r2 += 4; + packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0]; + numSlots = packet_p[1]; + packet_p += 4; gRfuLinkStatus->findParentCount = 0; - for (r6 = 0; r6 < 4 && r7 != 0; ++r6) - { - r7 -= 7; - r1 = r2 + 6; - r2 += 19; - r5 = ~*r2; - ++r2; - r4 = 0; - for (r3 = 0; r3 < 8; ++r3) + for (i = 0; i < RFU_CHILD_MAX && numSlots != 0; ++i) + { + numSlots -= 7; + uname_p = packet_p + 6; + packet_p += 19; + check_sum = ~*packet_p; + ++packet_p; + my_check_sum = 0; + for (j = 0; j < 8; ++j) { - r4 += *r2++; - r4 += *r1++; + my_check_sum += *packet_p++; + my_check_sum += *uname_p++; } - if (r4 == r5) + if (my_check_sum == check_sum) { - r2 -= 28; - r4_ = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount]; - r4_->id = *(u16 *)r2; - r2 += 2; - r4_->slot = *r2; - r2 += 2; - r4_->serialNo = *(u16 *)r2 & 0x7FFF; - if (*(u16 *)r2 & 0x8000) - r4_->mbootFlag = 1; + packet_p -= 28; + target = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount]; + target->id = *(u16 *)packet_p; + packet_p += 2; + target->slot = *packet_p; + packet_p += 2; + target->serialNo = *(u16 *)packet_p & 0x7FFF; + if (*(u16 *)packet_p & 0x8000) + target->mbootFlag = 1; else - r4_->mbootFlag = 0; - r2 += 2; - for (r3 = 0; r3 < RFU_GAME_NAME_LENGTH; ++r3) - r4_->gname[r3] = *r2++; - ++r2; - for (r3 = 0; r3 < RFU_USER_NAME_LENGTH; ++r3) - r4_->uname[r3] = *r2++; + target->mbootFlag = 0; + packet_p += 2; + for (j = 0; j < RFU_GAME_NAME_LENGTH; ++j) + target->gname[j] = *packet_p++; + ++packet_p; + for (j = 0; j < RFU_USER_NAME_LENGTH; ++j) + target->uname[j] = *packet_p++; ++gRfuLinkStatus->findParentCount; } } @@ -651,13 +720,13 @@ static void rfu_STC_readParentCandidateList(void) void rfu_REQ_startConnectParent(u16 pid) { - u16 r3 = 0; + u16 result = 0; u8 i; for (i = 0; i < RFU_CHILD_MAX && gRfuLinkStatus->partner[i].id != pid; ++i) ; - if (i == 4) - r3 = 256; - if (r3 == 0) + if (i == RFU_CHILD_MAX) + result = ERR_PID_NOT_FOUND; + if (result == 0) { gRfuStatic->tryPid = pid; STWI_set_Callback_M(rfu_STC_REQ_callback); @@ -665,7 +734,7 @@ void rfu_REQ_startConnectParent(u16 pid) } else { - rfu_STC_REQ_callback(31, r3); + rfu_STC_REQ_callback(ID_CP_START_REQ, result); } } @@ -675,70 +744,69 @@ void rfu_REQ_pollConnectParent(void) STWI_send_CP_PollingREQ(); } -static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) +static void rfu_CB_pollConnectParent(u8 reqCommand, u16 reqResult) { u16 id; u8 slot; - u8 r2, r5; - struct RfuTgtData *r9; - struct RfuTgtData sp; + u8 bm_slot_flag, i; + struct RfuTgtData *target_p; + struct RfuTgtData target_local; - if (sp28 == 0) + if (reqResult == 0) { id = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; slot = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6]; if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) { - r2 = 1 << slot; - if (!(r2 & gRfuLinkStatus->connSlotFlag)) + bm_slot_flag = 1 << slot; + if (!(bm_slot_flag & gRfuLinkStatus->connSlotFlag)) { - gRfuLinkStatus->connSlotFlag |= r2; - gRfuLinkStatus->linkLossSlotFlag &= ~r2; + gRfuLinkStatus->connSlotFlag |= bm_slot_flag; + gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag; gRfuLinkStatus->my.id = id; ++gRfuLinkStatus->connCount; gRfuLinkStatus->parentChild = MODE_CHILD; gRfuStatic->flags |= 0x80; - for (r5 = 0; r5 < RFU_CHILD_MAX; ++r5) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - if (gRfuLinkStatus->partner[r5].id == gRfuStatic->tryPid) + if (gRfuLinkStatus->partner[i].id == gRfuStatic->tryPid) { if (gRfuLinkStatus->findParentCount != 0) { - r9 = &sp; - CpuCopy16(&gRfuLinkStatus->partner[r5], &sp, sizeof(struct RfuTgtData)); + target_p = &target_local; + CpuCopy16(&gRfuLinkStatus->partner[i], &target_local, sizeof(struct RfuTgtData)); CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); gRfuLinkStatus->findParentCount = 0; } else { - r9 = &gRfuLinkStatus->partner[r5]; + target_p = &gRfuLinkStatus->partner[i]; } break; } } - if (r5 < RFU_CHILD_MAX) + if (i < RFU_CHILD_MAX) { - CpuCopy16(r9, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData)); + CpuCopy16(target_p, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData)); gRfuLinkStatus->partner[slot].slot = slot; } } } } - rfu_STC_REQ_callback(sp24, sp28); + rfu_STC_REQ_callback(reqCommand, reqResult); } u16 rfu_getConnectParentStatus(u8 *status, u8 *connectSlotNo) { - u8 r0, *r2; + u8 *packet_p; *status = 0xFF; - r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; - r0 = r2[0] + 96; - if (r0 <= 1) + packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + if (packet_p[0] == 0xa0 || packet_p[0] == 0xa1) { - r2 += 6; - *connectSlotNo = r2[0]; - *status = r2[1]; + packet_p += 6; + *connectSlotNo = packet_p[0]; + *status = packet_p[1]; return 0; } return ERR_REQ_CMD_ID; @@ -754,28 +822,28 @@ void rfu_REQ_endConnectParent(void) u16 rfu_syncVBlank(void) { - u8 r3, r4; - s32 r5; + u8 masterSlave, i; + s32 bmSlotFlag; rfu_NI_checkCommFailCounter(); if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) return 0; if (gRfuStatic->nowWatchInterval != 0) --gRfuStatic->nowWatchInterval; - r3 = rfu_getMasterSlave(); + masterSlave = rfu_getMasterSlave(); if (!(gRfuStatic->flags & 2)) { - if (r3 == 0) + if (masterSlave == AGB_CLK_SLAVE) { gRfuStatic->flags |= 4; gRfuStatic->watchdogTimer = 360; } } - else if (r3 != 0) + else if (masterSlave != AGB_CLK_SLAVE) { gRfuStatic->flags &= 0xFB; } - if (r3 != 0) + if (masterSlave != AGB_CLK_SLAVE) gRfuStatic->flags &= 0xFD; else gRfuStatic->flags |= 2; @@ -784,10 +852,10 @@ u16 rfu_syncVBlank(void) if (gRfuStatic->watchdogTimer == 0) { gRfuStatic->flags &= 0xFB; - r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; - for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) - if ((r5 >> r4) & 1) - rfu_STC_removeLinkData(r4, 1); + bmSlotFlag = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + for (i = 0; i < RFU_CHILD_MAX; ++i) + if ((bmSlotFlag >> i) & 1) + rfu_STC_removeLinkData(i, 1); gRfuLinkStatus->parentChild = MODE_NEUTRAL; return 1; } @@ -797,13 +865,13 @@ u16 rfu_syncVBlank(void) u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason, u8 *parentBmLinkRecoverySlot) { - u8 sp08 = 0; - u8 sp0C = 0; + u8 reasonMaybe = 0; + u8 reqResult = 0; u8 i; - s32 sp10, sp14; - u8 *r2; - u8 r9, r6, r3, connSlotFlag, r0; - + s32 stwiCommand, stwiParam; + u8 *packet_p; + u8 to_req_disconnect, newLinkLossFlag, num_packets, connSlotFlag, to_disconnect; + *bmLinkLossSlot = 0; *linkLossReason = REASON_DISCONNECTED; *parentBmLinkRecoverySlot = 0; @@ -814,25 +882,25 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason if (gRfuStatic->nowWatchInterval == 0) { gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval; - sp08 = 1; + reasonMaybe = 1; } - if ((u8)reqCommandId == 41) + if ((u8)reqCommandId == ID_DISCONNECTED_AND_CHANGE_REQ) { - u8 *r1 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; - - *bmLinkLossSlot = r1[4]; - *linkLossReason = r1[5]; + u8 *packet_p_2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + + *bmLinkLossSlot = packet_p_2[4]; + *linkLossReason = packet_p_2[5]; if (*linkLossReason == REASON_LINK_LOSS) *bmLinkLossSlot = gRfuLinkStatus->connSlotFlag; - sp08 = 2; + reasonMaybe = 2; } else { - if (reqCommandId == 310) + if (reqCommandId == 0x0136) { - r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5]; - r6 ^= gRfuLinkStatus->connSlotFlag; - *bmLinkLossSlot = r6 & gRfuLinkStatus->connSlotFlag; + newLinkLossFlag = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5]; + newLinkLossFlag ^= gRfuLinkStatus->connSlotFlag; + *bmLinkLossSlot = newLinkLossFlag & gRfuLinkStatus->connSlotFlag; *linkLossReason = REASON_LINK_LOSS; for (i = 0; i < RFU_CHILD_MAX; ++i) { @@ -843,33 +911,33 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason } } } - if (sp08 == 0) + if (reasonMaybe == 0) return 0; } - sp10 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command; - sp14 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + stwiCommand = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command; + stwiParam = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_LinkStatusREQ(); - sp0C = STWI_poll_CommandEnd(); - if (sp0C == 0) + reqResult = STWI_poll_CommandEnd(); + if (reqResult == 0) { - r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; for (i = 0; i < RFU_CHILD_MAX; ++i) - gRfuLinkStatus->strength[i] = *r2++; - r9 = 0; + gRfuLinkStatus->strength[i] = *packet_p++; + to_req_disconnect = 0; i = 0; } else { - rfu_STC_REQ_callback(17, sp0C); - return sp0C; + rfu_STC_REQ_callback(ID_LINK_STATUS_REQ, reqResult); + return reqResult; } for (; i < RFU_CHILD_MAX; ++i) { - r6 = 1 << i; - if (sp0C == 0) + newLinkLossFlag = 1 << i; + if (reqResult == 0) { - if (sp08 == 1 && (gRfuLinkStatus->connSlotFlag & r6)) + if (reasonMaybe == 1 && (gRfuLinkStatus->connSlotFlag & newLinkLossFlag)) { if (gRfuLinkStatus->strength[i] == 0) { @@ -878,8 +946,8 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason ++gRfuStatic->linkEmergencyFlag[i]; if (gRfuStatic->linkEmergencyFlag[i] > 3) { - *bmLinkLossSlot |= r6; - *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? + *bmLinkLossSlot |= newLinkLossFlag; + *linkLossReason = REASON_LINK_LOSS; } } else @@ -889,18 +957,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason { if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) { - *bmLinkLossSlot |= r6; - *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? + *bmLinkLossSlot |= newLinkLossFlag; + *linkLossReason = REASON_LINK_LOSS; } else { - if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->unk_1a) + if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->linkEmergencyLimit) { gRfuStatic->linkEmergencyFlag[i] = 0; STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag); STWI_poll_CommandEnd(); - *bmLinkLossSlot |= r6; - *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? + *bmLinkLossSlot |= newLinkLossFlag; + *linkLossReason = REASON_LINK_LOSS; } } } @@ -908,18 +976,18 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason } else { - gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? + gRfuStatic->linkEmergencyFlag[i] = 0; } } if (gRfuLinkStatus->parentChild == MODE_PARENT && gRfuLinkStatus->strength[i] != 0) { - if (r6 & gRfuLinkStatus->linkLossSlotFlag) + if (newLinkLossFlag & gRfuLinkStatus->linkLossSlotFlag) { if (gRfuLinkStatus->strength[i] > 10) { - *parentBmLinkRecoverySlot |= r6; - gRfuLinkStatus->connSlotFlag |= r6; - gRfuLinkStatus->linkLossSlotFlag &= ~r6; + *parentBmLinkRecoverySlot |= newLinkLossFlag; + gRfuLinkStatus->connSlotFlag |= newLinkLossFlag; + gRfuLinkStatus->linkLossSlotFlag &= ~newLinkLossFlag; ++gRfuLinkStatus->connCount; gRfuStatic->linkEmergencyFlag[i] = 0; } @@ -930,19 +998,19 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason } else { - if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r6)) + if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & newLinkLossFlag)) { STWI_send_SlotStatusREQ(); STWI_poll_CommandEnd(); - r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; - r3 = r2[1] - 1; - for (r2 += 8; r3 != 0; r2 += 4, --r3) + packet_p = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + num_packets = packet_p[1] - 1; + for (packet_p += 8; num_packets != 0; packet_p += 4, --num_packets) { - u16 r4 = *(u16 *)r2; + u16 cid = *(u16 *)packet_p; - if (r2[2] == i && r4 == gRfuStatic->cidBak[i]) + if (packet_p[2] == i && cid == gRfuStatic->cidBak[i]) { - r9 |= 1 << i; + to_req_disconnect |= 1 << i; break; } } @@ -951,46 +1019,46 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason } } connSlotFlag = gRfuLinkStatus->connSlotFlag; - r0 = *bmLinkLossSlot; - r0 &= connSlotFlag; - if (r6 & r0) + to_disconnect = *bmLinkLossSlot; + to_disconnect &= connSlotFlag; + if (newLinkLossFlag & to_disconnect) rfu_STC_removeLinkData(i, 0); } - if (r9 != 0) + if (to_req_disconnect != 0) { - STWI_send_DisconnectREQ(r9); + STWI_send_DisconnectREQ(to_req_disconnect); STWI_poll_CommandEnd(); } // equivalent to: - // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = sp10; - *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = sp10; - gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = sp14; + // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = stwiCommand; + *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = stwiCommand; + gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = stwiParam; return 0; } -static void rfu_STC_removeLinkData(u8 r7, u8 r12) +static void rfu_STC_removeLinkData(u8 bmConnectedPartnerId, u8 bmDisconnect) { - u8 r5 = 1 << r7; - s32 r6; + u8 bmLinkLossFlag = 1 << bmConnectedPartnerId; + s32 bmLinkRetainedFlag; - if ((gRfuLinkStatus->connSlotFlag & r5) && gRfuLinkStatus->connCount != 0) + if ((gRfuLinkStatus->connSlotFlag & bmLinkLossFlag) && gRfuLinkStatus->connCount != 0) --gRfuLinkStatus->connCount; - gRfuLinkStatus->connSlotFlag &= r6 = ~r5; - gRfuLinkStatus->linkLossSlotFlag |= r5; - if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0) + gRfuLinkStatus->connSlotFlag &= bmLinkRetainedFlag = ~bmLinkLossFlag; + gRfuLinkStatus->linkLossSlotFlag |= bmLinkLossFlag; + if (gRfuLinkStatus->parentChild == MODE_CHILD && gRfuLinkStatus->connSlotFlag == 0) gRfuLinkStatus->parentChild = MODE_NEUTRAL; - if (r12 != 0) + if (bmDisconnect) { - CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData)); - gRfuLinkStatus->linkLossSlotFlag &= r6; - gRfuLinkStatus->getNameFlag &= r6; - gRfuLinkStatus->strength[r7] = 0; + CpuFill16(0, &gRfuLinkStatus->partner[bmConnectedPartnerId], sizeof(struct RfuTgtData)); + gRfuLinkStatus->linkLossSlotFlag &= bmLinkRetainedFlag; + gRfuLinkStatus->getNameFlag &= bmLinkRetainedFlag; + gRfuLinkStatus->strength[bmConnectedPartnerId] = 0; } } void rfu_REQ_disconnect(u8 bmDisconnectSlot) { - u16 r1; + u16 result; if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmDisconnectSlot) { @@ -1003,9 +1071,9 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot) else if (gRfuStatic->SCStartFlag && (STWI_set_Callback_M(rfu_CB_defaultCallback), STWI_send_SC_EndREQ(), - (r1 = STWI_poll_CommandEnd()) != 0)) + (result = STWI_poll_CommandEnd()) != 0)) { - rfu_STC_REQ_callback(27, r1); + rfu_STC_REQ_callback(ID_SC_END_REQ, result); } else { @@ -1015,38 +1083,38 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot) } } -static void rfu_CB_disconnect(u8 r6, u16 r5) +static void rfu_CB_disconnect(u8 reqCommand, u16 reqResult) { - u8 r4, r0; + u8 i, bm_slot_flag; - if (r5 == 3 && gRfuLinkStatus->parentChild == MODE_CHILD) + if (reqResult == 3 && gRfuLinkStatus->parentChild == MODE_CHILD) { STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_SystemStatusREQ(); if (STWI_poll_CommandEnd() == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) - r5 = 0; + reqResult = 0; } gRfuStatic->recoveryBmSlot &= gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8] = gRfuStatic->recoveryBmSlot; - if (r5 == 0) + if (reqResult == 0) { - for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - r0 = 1 << r4; - if (r0 & gRfuStatic->recoveryBmSlot) - rfu_STC_removeLinkData(r4, 1); + bm_slot_flag = 1 << i; + if (bm_slot_flag & gRfuStatic->recoveryBmSlot) + rfu_STC_removeLinkData(i, 1); } } if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0) gRfuLinkStatus->parentChild = MODE_NEUTRAL; - rfu_STC_REQ_callback(r6, r5); + rfu_STC_REQ_callback(reqCommand, reqResult); if (gRfuStatic->SCStartFlag) { STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_SC_StartREQ(); - r5 = STWI_poll_CommandEnd(); - if (r5 != 0) - rfu_STC_REQ_callback(25, r5); + reqResult = STWI_poll_CommandEnd(); + if (reqResult != 0) + rfu_STC_REQ_callback(ID_SC_START_REQ, reqResult); } } @@ -1068,38 +1136,35 @@ void rfu_REQ_CHILD_pollConnectRecovery(void) STWI_send_CPR_PollingREQ(); } -static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) +static void rfu_CB_CHILD_pollConnectRecovery(u8 reqCommand, u16 reqResult) { - u8 r3, r4; - struct RfuLinkStatus *r2; + u8 bm_slot_flag, i; + struct RfuLinkStatus *rfuLinkStatus; - if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot) + if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot) { gRfuLinkStatus->parentChild = MODE_CHILD; - for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - r3 = 1 << r4; - r2 = gRfuLinkStatus; // ??? - if (gRfuStatic->recoveryBmSlot & r3 & r2->linkLossSlotFlag) + bm_slot_flag = 1 << i; + rfuLinkStatus = gRfuLinkStatus; // ??? + if (gRfuStatic->recoveryBmSlot & bm_slot_flag & rfuLinkStatus->linkLossSlotFlag) { - gRfuLinkStatus->connSlotFlag |= r3; - gRfuLinkStatus->linkLossSlotFlag &= ~r3; + gRfuLinkStatus->connSlotFlag |= bm_slot_flag; + gRfuLinkStatus->linkLossSlotFlag &= ~bm_slot_flag; ++gRfuLinkStatus->connCount; - gRfuStatic->linkEmergencyFlag[r4] = 0; + gRfuStatic->linkEmergencyFlag[i] = 0; } } gRfuStatic->recoveryBmSlot = 0; } - rfu_STC_REQ_callback(r8, r7); + rfu_STC_REQ_callback(reqCommand, reqResult); } u16 rfu_CHILD_getConnectRecoveryStatus(u8 *status) { - u8 r0; - *status = 0xFF; - r0 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] + 77; - if (r0 <= 1) + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB3 || gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] == 0xB4) { *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; return 0; @@ -1127,14 +1192,14 @@ static void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size) void rfu_REQ_changeMasterSlave(void) { - if (STWI_read_status(1) == 1) + if (STWI_read_status(1) == AGB_CLK_MASTER) { STWI_set_Callback_M(rfu_STC_REQ_callback); STWI_send_MS_ChangeREQ(); } else { - rfu_STC_REQ_callback(39, 0); + rfu_STC_REQ_callback(ID_MS_CHANGE_REQ, 0); } } @@ -1144,11 +1209,11 @@ bool8 rfu_getMasterSlave(void) if (masterSlave == AGB_CLK_MASTER) { - if (gSTWIStatus->unk_2c) + if (gSTWIStatus->sending) { - if (gSTWIStatus->reqActiveCommand == 39 - || gSTWIStatus->reqActiveCommand == 37 - || gSTWIStatus->reqActiveCommand == 55) + if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ + || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) masterSlave = AGB_CLK_SLAVE; } } @@ -1159,7 +1224,7 @@ void rfu_clearAllSlot(void) { u16 i; u16 IMEBackup = REG_IME; - + REG_IME = 0; for (i = 0; i < RFU_CHILD_MAX; ++i) { @@ -1175,87 +1240,87 @@ void rfu_clearAllSlot(void) REG_IME = IMEBackup; } -static void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4) +static void rfu_STC_releaseFrame(u8 bm_slot_id, u8 send_recv, struct NIComm *NI_comm) { if (!(gRfuStatic->flags & 0x80)) { - if (r3 == 0) - gRfuLinkStatus->remainLLFrameSizeParent += r4->payloadSize; + if (send_recv == 0) + gRfuLinkStatus->remainLLFrameSizeParent += NI_comm->payloadSize; gRfuLinkStatus->remainLLFrameSizeParent += 3; } else { - if (r3 == 0) - gRfuLinkStatus->remainLLFrameSizeChild[r5] += r4->payloadSize; - gRfuLinkStatus->remainLLFrameSizeChild[r5] += 2; + if (send_recv == 0) + gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += NI_comm->payloadSize; + gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id] += 2; } } u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) { - u16 r10, r3, r1; - struct NIComm *r4; + u16 imeBak, send_recv, i; + struct NIComm *NI_comm; if (slotStatusIndex >= RFU_CHILD_MAX) return ERR_SLOT_NO; if (!(connTypeFlag & (TYPE_UNI_SEND | TYPE_UNI_RECV | TYPE_NI_SEND | TYPE_NI_RECV))) return ERR_COMM_TYPE; - r10 = REG_IME; + imeBak = REG_IME; REG_IME = 0; if (connTypeFlag & (TYPE_NI_SEND | TYPE_NI_RECV)) { - for (r3 = 0; r3 < 2; ++r3) + for (send_recv = 0; send_recv < 2; ++send_recv) { - r4 = NULL; - if (r3 == 0) + NI_comm = NULL; + if (send_recv == 0) { if (connTypeFlag & TYPE_NI_SEND) { - r4 = &gRfuSlotStatusNI[slotStatusIndex]->send; - gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg; + NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->send; + gRfuLinkStatus->sendSlotNIFlag &= ~NI_comm->bmSlotOrg; } } else { if (connTypeFlag & TYPE_NI_RECV) { - r4 = &gRfuSlotStatusNI[slotStatusIndex]->recv; + NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv; gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); } } - if (r4 != NULL) + if (NI_comm != NULL) { - if (r4->state & SLOT_BUSY_FLAG) + if (NI_comm->state & SLOT_BUSY_FLAG) { - rfu_STC_releaseFrame(slotStatusIndex, r3, r4); - for (r1 = 0; r1 < RFU_CHILD_MAX; ++r1) - if ((r4->bmSlotOrg >> r1) & 1) - r4->failCounter = 0; + rfu_STC_releaseFrame(slotStatusIndex, send_recv, NI_comm); + for (i = 0; i < RFU_CHILD_MAX; ++i) + if ((NI_comm->bmSlotOrg >> i) & 1) + NI_comm->failCounter = 0; } - CpuFill16(0, r4, sizeof(struct NIComm)); + CpuFill16(0, NI_comm, sizeof(struct NIComm)); } } } if (connTypeFlag & TYPE_UNI_SEND) { - struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[slotStatusIndex]; + struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[slotStatusIndex]; - if (r3->send.state & SLOT_BUSY_FLAG) + if (slotStatusUNI->send.state & SLOT_BUSY_FLAG) { if (!(gRfuStatic->flags & 0x80)) - gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->send.payloadSize; + gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)slotStatusUNI->send.payloadSize; else - gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)r3->send.payloadSize; - gRfuLinkStatus->sendSlotUNIFlag &= ~r3->send.bmSlot; + gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)slotStatusUNI->send.payloadSize; + gRfuLinkStatus->sendSlotUNIFlag &= ~slotStatusUNI->send.bmSlot; } - CpuFill16(0, &r3->send, sizeof(struct UNISend)); + CpuFill16(0, &slotStatusUNI->send, sizeof(struct UNISend)); } if (connTypeFlag & TYPE_UNI_RECV) { CpuFill16(0, &gRfuSlotStatusUNI[slotStatusIndex]->recv, sizeof(struct UNIRecv)); } - REG_IME = r10; + REG_IME = imeBak; return 0; } @@ -1301,16 +1366,16 @@ u16 rfu_NI_CHILD_setSendGameName(u8 slotNo, u8 subFrameSize) return rfu_STC_setSendData_org(64, 1 << slotNo, subFrameSize, &gRfuLinkStatus->my.serialNo, 26); } -static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 sp28) +static u16 rfu_STC_setSendData_org(u8 ni_or_uni, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 dataSize) { - u8 r2, r0; - u8 r4; - u8 *r9; - u8 r5; + u8 bm_slot_id, sendSlotFlag; + u8 frameSize; + u8 *llFrameSize_p; + u8 sending; u8 i; - u16 sp04; - struct RfuSlotStatusUNI *r1; - struct RfuSlotStatusNI *r12; + u16 imeBak; + struct RfuSlotStatusUNI *slotStatus_UNI; + struct RfuSlotStatusNI *slotStatus_NI; if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) return ERR_MODE_NOT_CONNECTED; @@ -1318,108 +1383,108 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const return ERR_SLOT_NO; if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmSendSlot) != bmSendSlot) return ERR_SLOT_NOT_CONNECTED; - if (r6 & 0x10) - r0 = gRfuLinkStatus->sendSlotUNIFlag; + if (ni_or_uni & 0x10) + sendSlotFlag = gRfuLinkStatus->sendSlotUNIFlag; else - r0 = gRfuLinkStatus->sendSlotNIFlag; - if (r0 & bmSendSlot) + sendSlotFlag = gRfuLinkStatus->sendSlotNIFlag; + if (sendSlotFlag & bmSendSlot) return ERR_SLOT_BUSY; - for (r2 = 0; r2 < RFU_CHILD_MAX && !((bmSendSlot >> r2) & 1); ++r2) + for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX && !((bmSendSlot >> bm_slot_id) & 1); ++bm_slot_id) ; if (gRfuLinkStatus->parentChild == MODE_PARENT) - r9 = &gRfuLinkStatus->remainLLFrameSizeParent; + llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent; else if (gRfuLinkStatus->parentChild == MODE_CHILD) - r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; - r4 = llsf_struct[gRfuLinkStatus->parentChild].unk00; - if (subFrameSize > *r9 || subFrameSize <= r4) + llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id]; + frameSize = llsf_struct[gRfuLinkStatus->parentChild].frameSize; + if (subFrameSize > *llFrameSize_p || subFrameSize <= frameSize) return ERR_SUBFRAME_SIZE; - sp04 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - r5 = r6 & 0x20; - if (r5 || r6 == 0x40) - { - u8 *r1; // a hack to swap instructions - - r12 = gRfuSlotStatusNI[r2]; - r1 = NULL; - r12->send.errorCode = 0; - *r12->send.now_p = r1 = &r12->send.dataType; - r12->send.remainSize = 7; - r12->send.bmSlotOrg = bmSendSlot; - r12->send.bmSlot = bmSendSlot; - r12->send.payloadSize = subFrameSize - r4; - if (r5 != 0) - *r1 = 0; + sending = ni_or_uni & 0x20; + if (sending || ni_or_uni == 0x40) + { + u8 *dataType_p; // a hack to swap instructions + + slotStatus_NI = gRfuSlotStatusNI[bm_slot_id]; + slotStatus_UNI = NULL; + slotStatus_NI->send.errorCode = 0; + *slotStatus_NI->send.now_p = dataType_p = &slotStatus_NI->send.dataType; + slotStatus_NI->send.remainSize = 7; + slotStatus_NI->send.bmSlotOrg = bmSendSlot; + slotStatus_NI->send.bmSlot = bmSendSlot; + slotStatus_NI->send.payloadSize = subFrameSize - frameSize; + if (sending != 0) + *dataType_p = 0; else - *r1 = 1; - r12->send.dataSize = sp28; - r12->send.src = src; - r12->send.ack = 0; - r12->send.phase = 0; - #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette + *dataType_p = 1; + slotStatus_NI->send.dataSize = dataSize; + slotStatus_NI->send.src = src; + slotStatus_NI->send.ack = 0; + slotStatus_NI->send.phase = 0; + #ifndef NONMATCHING // to fix bm_slot_id, r3, frameSize, sending register roulette asm("":::"r2"); #endif for (i = 0; i < WINDOW_COUNT; ++i) { - r12->send.recvAckFlag[i] = 0; - r12->send.n[i] = 1; + slotStatus_NI->send.recvAckFlag[i] = 0; + slotStatus_NI->send.n[i] = 1; } - for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2) - if ((bmSendSlot >> r2) & 1) - gRfuSlotStatusNI[r2]->send.failCounter = 0; + for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id) + if ((bmSendSlot >> bm_slot_id) & 1) + gRfuSlotStatusNI[bm_slot_id]->send.failCounter = 0; gRfuLinkStatus->sendSlotNIFlag |= bmSendSlot; - *r9 -= subFrameSize; - r12->send.state = SLOT_STATE_SEND_START; + *llFrameSize_p -= subFrameSize; + slotStatus_NI->send.state = SLOT_STATE_SEND_START; } - else if (r6 & 0x10) + else if (ni_or_uni & 0x10) { - r1 = gRfuSlotStatusUNI[r2]; - r1->send.bmSlot = bmSendSlot; - r1->send.src = src; - r1->send.payloadSize = subFrameSize - r4; - *r9 -= subFrameSize; - r1->send.state = SLOT_STATE_SEND_UNI; + slotStatus_UNI = gRfuSlotStatusUNI[bm_slot_id]; + slotStatus_UNI->send.bmSlot = bmSendSlot; + slotStatus_UNI->send.src = src; + slotStatus_UNI->send.payloadSize = subFrameSize - frameSize; + *llFrameSize_p -= subFrameSize; + slotStatus_UNI->send.state = SLOT_STATE_SEND_UNI; gRfuLinkStatus->sendSlotUNIFlag |= bmSendSlot; } - REG_IME = sp04; + REG_IME = imeBak; return 0; } u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) { - struct RfuSlotStatusNI *r5; - u16 r8; - u8 r2; + struct RfuSlotStatusNI *slotStatusNI; + u16 imeBak; + u8 i; if (slotStatusIndex >= RFU_CHILD_MAX) return ERR_SLOT_NO; if (connType == 0x20) { - r5 = gRfuSlotStatusNI[slotStatusIndex]; - if ((r5->send.state & SLOT_BUSY_FLAG) - && (r5->send.state & SLOT_SEND_FLAG)) + slotStatusNI = gRfuSlotStatusNI[slotStatusIndex]; + if ((slotStatusNI->send.state & SLOT_BUSY_FLAG) + && (slotStatusNI->send.state & SLOT_SEND_FLAG)) { - connType = bmNewTgtSlot ^ r5->send.bmSlot; - + connType = bmNewTgtSlot ^ slotStatusNI->send.bmSlot; + if (!(connType & bmNewTgtSlot)) { if (connType) { - r8 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - if ((connType >> r2) & 1) - gRfuSlotStatusNI[r2]->send.failCounter = 0; + if ((connType >> i) & 1) + gRfuSlotStatusNI[i]->send.failCounter = 0; } gRfuLinkStatus->sendSlotNIFlag &= ~connType; - r5->send.bmSlot = bmNewTgtSlot; - if (r5->send.bmSlot == 0) + slotStatusNI->send.bmSlot = bmNewTgtSlot; + if (slotStatusNI->send.bmSlot == 0) { - rfu_STC_releaseFrame(slotStatusIndex, 0, &r5->send); - r5->send.state = SLOT_STATE_SEND_FAILED; + rfu_STC_releaseFrame(slotStatusIndex, 0, &slotStatusNI->send); + slotStatusNI->send.state = SLOT_STATE_SEND_FAILED; } - REG_IME = r8; + REG_IME = imeBak; } } else @@ -1436,21 +1501,21 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) { if (connType == 16) { - s32 r3; + s32 bmSlot; if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != SLOT_STATE_SEND_UNI) return ERR_SLOT_NOT_SENDING; - for (r3 = 0, r2 = 0; r2 < RFU_CHILD_MAX; ++r2) - if (r2 != slotStatusIndex) - r3 |= gRfuSlotStatusUNI[r2]->send.bmSlot; - if (bmNewTgtSlot & r3) + for (bmSlot = 0, i = 0; i < RFU_CHILD_MAX; ++i) + if (i != slotStatusIndex) + bmSlot |= gRfuSlotStatusUNI[i]->send.bmSlot; + if (bmNewTgtSlot & bmSlot) return ERR_SLOT_TARGET; - r8 = REG_IME; + imeBak = REG_IME; REG_IME = 0; gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot; gRfuLinkStatus->sendSlotUNIFlag |= bmNewTgtSlot; gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot = bmNewTgtSlot; - REG_IME = r8; + REG_IME = imeBak; } else { @@ -1462,14 +1527,14 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) u16 rfu_NI_stopReceivingData(u8 slotStatusIndex) { - struct NIComm *r5; - u16 r4, r1; + struct NIComm *NI_comm; + u16 imeBak; if (slotStatusIndex >= RFU_CHILD_MAX) return ERR_SLOT_NO; - r5 = &gRfuSlotStatusNI[slotStatusIndex]->recv; - r4 = REG_IME; - ++r4; --r4; // fix r4, r5 register swap + NI_comm = &gRfuSlotStatusNI[slotStatusIndex]->recv; + imeBak = REG_IME; + ++imeBak; --imeBak; // fix imeBak, NI_comm register swap REG_IME = 0; if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & SLOT_BUSY_FLAG) { @@ -1478,43 +1543,43 @@ u16 rfu_NI_stopReceivingData(u8 slotStatusIndex) else gRfuSlotStatusNI[slotStatusIndex]->recv.state = SLOT_STATE_RECV_FAILED; gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); - rfu_STC_releaseFrame(slotStatusIndex, 1, r5); + rfu_STC_releaseFrame(slotStatusIndex, 1, NI_comm); } - REG_IME = r4; + REG_IME = imeBak; return 0; } u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size) { - struct UNISend *r4; - u8 *r6; - u16 r1; - u8 r3_; + struct UNISend *UNI_send; + u8 *frame_p; + u16 imeBak; + u8 frameEnd; if (slotStatusIndex >= RFU_CHILD_MAX) return ERR_SLOT_NO; - r4 = &gRfuSlotStatusUNI[slotStatusIndex]->send; - if (r4->state != SLOT_STATE_SEND_UNI) + UNI_send = &gRfuSlotStatusUNI[slotStatusIndex]->send; + if (UNI_send->state != SLOT_STATE_SEND_UNI) return ERR_SLOT_NOT_SENDING; if (gRfuLinkStatus->parentChild == MODE_PARENT) { - r6 = &gRfuLinkStatus->remainLLFrameSizeParent; - r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize; + frame_p = &gRfuLinkStatus->remainLLFrameSizeParent; + frameEnd = gRfuLinkStatus->remainLLFrameSizeParent + (u8)UNI_send->payloadSize; } else { - r6 = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex]; - r3_ = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)r4->payloadSize; + frame_p = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex]; + frameEnd = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)UNI_send->payloadSize; } - if (r3_ < size) + if (frameEnd < size) return ERR_SUBFRAME_SIZE; - r1 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - r4->src = src; - *r6 = r3_ - size; - r4->payloadSize = size; - r4->dataReadyFlag = 1; - REG_IME = r1; + UNI_send->src = src; + *frame_p = frameEnd - size; + UNI_send->payloadSize = size; + UNI_send->dataReadyFlag = 1; + REG_IME = imeBak; return 0; } @@ -1593,184 +1658,184 @@ void rfu_REQ_sendData(bool8 clockChangeFlag) } } -static void rfu_CB_sendData(UNUSED u8 r0, u16 r7) +static void rfu_CB_sendData(UNUSED u8 reqCommand, u16 reqResult) { - u8 r6; - struct NIComm *r4; + u8 i; + struct NIComm *NI_comm; - if (r7 == 0) + if (reqResult == 0) { - for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - if (gRfuSlotStatusUNI[r6]->send.dataReadyFlag) - gRfuSlotStatusUNI[r6]->send.dataReadyFlag = 0; - r4 = &gRfuSlotStatusNI[r6]->send; - if (r4->state == SLOT_STATE_SEND_NULL) + if (gRfuSlotStatusUNI[i]->send.dataReadyFlag) + gRfuSlotStatusUNI[i]->send.dataReadyFlag = 0; + NI_comm = &gRfuSlotStatusNI[i]->send; + if (NI_comm->state == SLOT_STATE_SEND_NULL) { - rfu_STC_releaseFrame(r6, 0, r4); - gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlot; - if (r4->dataType == 1) - gRfuLinkStatus->getNameFlag |= 1 << r6; - r4->state = SLOT_STATE_SEND_SUCCESS; + rfu_STC_releaseFrame(i, 0, NI_comm); + gRfuLinkStatus->sendSlotNIFlag &= ~NI_comm->bmSlot; + if (NI_comm->dataType == 1) + gRfuLinkStatus->getNameFlag |= 1 << i; + NI_comm->state = SLOT_STATE_SEND_SUCCESS; } } } gRfuLinkStatus->LLFReadyFlag = 0; - rfu_STC_REQ_callback(36, r7); + rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult); } -static void rfu_CB_sendData2(UNUSED u8 r0, u16 r1) +static void rfu_CB_sendData2(UNUSED u8 reqCommand, u16 reqResult) { - rfu_STC_REQ_callback(36, r1); + rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult); } -static void rfu_CB_sendData3(u8 r0, u16 r1) +static void rfu_CB_sendData3(u8 reqCommand, u16 reqResult) { - if (r1 != 0) - rfu_STC_REQ_callback(36, r1); - else if (r0 == 0xFF) - rfu_STC_REQ_callback(0xFF, 0); + if (reqResult != 0) + rfu_STC_REQ_callback(ID_DATA_TX_REQ, reqResult); + else if (reqCommand == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ) + rfu_STC_REQ_callback(ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ, 0); } static void rfu_constructSendLLFrame(void) { - u32 r8, r5; - u8 r6; - u8 *sp00; - struct RfuSlotStatusNI *r2; + u32 pakcketSize, currSize; + u8 i; + u8 *llf_p; + struct RfuSlotStatusNI *slotStatusNI; if (gRfuLinkStatus->parentChild != MODE_NEUTRAL && gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag) { gRfuLinkStatus->LLFReadyFlag = 0; - r8 = 0; - sp00 = (u8 *)&gRfuFixed->LLFBuffer[1]; - for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) + pakcketSize = 0; + llf_p = (u8 *)&gRfuFixed->LLFBuffer[1]; + for (i = 0; i < RFU_CHILD_MAX; ++i) { - r5 = 0; - if (gRfuSlotStatusNI[r6]->send.state & SLOT_BUSY_FLAG) - r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->send); - if (gRfuSlotStatusNI[r6]->recv.state & SLOT_BUSY_FLAG) - r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->recv); - if (gRfuSlotStatusUNI[r6]->send.state == SLOT_STATE_SEND_UNI) - r5 += rfu_STC_UNI_constructLLSF(r6, &sp00); - if (r5 != 0) + currSize = 0; + if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG) + currSize = rfu_STC_NI_constructLLSF(i, &llf_p, &gRfuSlotStatusNI[i]->send); + if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG) + currSize += rfu_STC_NI_constructLLSF(i, &llf_p, &gRfuSlotStatusNI[i]->recv); + if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI) + currSize += rfu_STC_UNI_constructLLSF(i, &llf_p); + if (currSize != 0) { if (gRfuLinkStatus->parentChild == MODE_PARENT) - r8 += r5; + pakcketSize += currSize; else - r8 |= r5 << (5 * r6 + 8); + pakcketSize |= currSize << (5 * i + 8); } } - if (r8 != 0) + if (pakcketSize != 0) { - while ((u32)sp00 & 3) - *sp00++ = 0; - gRfuFixed->LLFBuffer[0] = r8; + while ((u32)llf_p & 3) + *llf_p++ = 0; + gRfuFixed->LLFBuffer[0] = pakcketSize; if (gRfuLinkStatus->parentChild == MODE_CHILD) { - u8 *r0 = sp00 - offsetof(struct RfuFixed, LLFBuffer[1]); - - // Does the volatile qualifier make sense? - // It's the same as: + u8 *maxSize = llf_p - offsetof(struct RfuFixed, LLFBuffer[1]); + + // Does the volatile qualifier make sense? + // It's the same as: // asm("":::"memory"); - r8 = r0 - *(u8 *volatile *)&gRfuFixed; + pakcketSize = maxSize - *(u8 *volatile *)&gRfuFixed; } } - gRfuStatic->totalPacketSize = r8; + gRfuStatic->totalPacketSize = pakcketSize; } } -static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) +static u16 rfu_STC_NI_constructLLSF(u8 bm_slot_id, u8 **dest_pp, struct NIComm *NI_comm) { - u16 r5; - u32 sp00; + u16 size; + u32 frame; u8 i; - u8 *r2; - const struct LLSFStruct *r8 = &llsf_struct[gRfuLinkStatus->parentChild]; + u8 *frame8_p; + const struct LLSFStruct *llsf = &llsf_struct[gRfuLinkStatus->parentChild]; - if (r4->state == SLOT_STATE_SENDING) + if (NI_comm->state == SLOT_STATE_SENDING) { - while (r4->now_p[r4->phase] >= (const u8 *)r4->src + r4->dataSize) + while (NI_comm->now_p[NI_comm->phase] >= (const u8 *)NI_comm->src + NI_comm->dataSize) { - ++r4->phase; - if (r4->phase == 4) - r4->phase = 0; + ++NI_comm->phase; + if (NI_comm->phase == 4) + NI_comm->phase = 0; } } - if (r4->state & SLOT_RECV_FLAG) + if (NI_comm->state & SLOT_RECV_FLAG) { - r5 = 0; + size = 0; } - else if (r4->state == SLOT_STATE_SENDING) + else if (NI_comm->state == SLOT_STATE_SENDING) { - if (r4->now_p[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize) - r5 = (const u8 *)r4->src + r4->dataSize - r4->now_p[r4->phase]; + if (NI_comm->now_p[NI_comm->phase] + NI_comm->payloadSize > (const u8 *)NI_comm->src + NI_comm->dataSize) + size = (const u8 *)NI_comm->src + NI_comm->dataSize - NI_comm->now_p[NI_comm->phase]; else - r5 = r4->payloadSize; + size = NI_comm->payloadSize; } else { - if ((u32)r4->remainSize >= r4->payloadSize) - r5 = r4->payloadSize; + if ((u32)NI_comm->remainSize >= NI_comm->payloadSize) + size = NI_comm->payloadSize; else - r5 = r4->remainSize; + size = NI_comm->remainSize; } - sp00 = (r4->state & 0xF) << r8->unk03 - | r4->ack << r8->unk04 - | r4->phase << r8->unk05 - | r4->n[r4->phase] << r8->unk06 - | r5; + frame = (NI_comm->state & 0xF) << llsf->slotStateShift + | NI_comm->ack << llsf->ackShift + | NI_comm->phase << llsf->phaseShit + | NI_comm->n[NI_comm->phase] << llsf->nShift + | size; if (gRfuLinkStatus->parentChild == MODE_PARENT) - sp00 |= r4->bmSlot << 18; - r2 = (u8 *)&sp00; - for (i = 0; i < r8->unk00; ++i) - *(*r12)++ = *r2++; - if (r5 != 0) + frame |= NI_comm->bmSlot << 18; + frame8_p = (u8 *)&frame; + for (i = 0; i < llsf->frameSize; ++i) + *(*dest_pp)++ = *frame8_p++; + if (size != 0) { - const u8 *sp04 = r4->now_p[r4->phase]; + const u8 *src = NI_comm->now_p[NI_comm->phase]; - gRfuFixed->fastCopyPtr(&sp04, r12, r5); + gRfuFixed->fastCopyPtr(&src, dest_pp, size); } - if (r4->state == SLOT_STATE_SENDING) + if (NI_comm->state == SLOT_STATE_SENDING) { - ++r4->phase; - if (r4->phase == 4) - r4->phase = 0; + ++NI_comm->phase; + if (NI_comm->phase == 4) + NI_comm->phase = 0; } if (gRfuLinkStatus->parentChild == MODE_PARENT) gRfuLinkStatus->LLFReadyFlag = 1; else - gRfuLinkStatus->LLFReadyFlag |= 1 << r10; - return r5 + r8->unk00; + gRfuLinkStatus->LLFReadyFlag |= 1 << bm_slot_id; + return size + llsf->frameSize; } -static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) +static u16 rfu_STC_UNI_constructLLSF(u8 bm_slot_id, u8 **dest_p) { - const struct LLSFStruct *r5; - const u8 *sp04; - u32 sp00; - u8 *r2; + const struct LLSFStruct *llsf; + const u8 *src_p; + u32 frame; + u8 *frame8_p; u8 i; - struct UNISend *r4 = &gRfuSlotStatusUNI[r8]->send; + struct UNISend *UNI_send = &gRfuSlotStatusUNI[bm_slot_id]->send; - if (!r4->dataReadyFlag || !r4->bmSlot) + if (!UNI_send->dataReadyFlag || !UNI_send->bmSlot) return 0; - r5 = &llsf_struct[gRfuLinkStatus->parentChild]; - sp00 = (r4->state & 0xF) << r5->unk03 - | r4->payloadSize; + llsf = &llsf_struct[gRfuLinkStatus->parentChild]; + frame = (UNI_send->state & 0xF) << llsf->slotStateShift + | UNI_send->payloadSize; if (gRfuLinkStatus->parentChild == MODE_PARENT) - sp00 |= r4->bmSlot << 18; - r2 = (u8 *)&sp00; - for (i = 0; i < r5->unk00; ++i) - *(*r6)++ = *r2++; - sp04 = r4->src; - gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize); + frame |= UNI_send->bmSlot << 18; + frame8_p = (u8 *)&frame; + for (i = 0; i < llsf->frameSize; ++i) + *(*dest_p)++ = *frame8_p++; + src_p = UNI_send->src; + gRfuFixed->fastCopyPtr(&src_p, dest_p, UNI_send->payloadSize); if (gRfuLinkStatus->parentChild == MODE_PARENT) gRfuLinkStatus->LLFReadyFlag = 16; else - gRfuLinkStatus->LLFReadyFlag |= 16 << r8; - return r5->unk00 + r4->payloadSize; + gRfuLinkStatus->LLFReadyFlag |= 16 << bm_slot_id; + return llsf->frameSize + UNI_send->payloadSize; } void rfu_REQ_recvData(void) @@ -1784,434 +1849,433 @@ void rfu_REQ_recvData(void) } } -static void rfu_CB_recvData(u8 r9, u16 r7) +static void rfu_CB_recvData(u8 reqCommand, u16 reqResult) { - u8 r6; - struct RfuSlotStatusNI *r4; - struct NIComm *r5; + u8 i; + struct RfuSlotStatusNI *slotStatusNI; + struct NIComm *NI_comm; - if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]) + if (reqResult == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]) { gRfuStatic->NIEndRecvFlag = 0; if (gRfuLinkStatus->parentChild == MODE_PARENT) rfu_STC_PARENT_analyzeRecvPacket(); else rfu_STC_CHILD_analyzeRecvPacket(); - for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - r4 = gRfuSlotStatusNI[r6]; - if (r4->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) + slotStatusNI = gRfuSlotStatusNI[i]; + if (slotStatusNI->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> i) & 1)) { - r5 = &r4->recv; - if (r5->dataType == 1) - gRfuLinkStatus->getNameFlag |= 1 << r6; - rfu_STC_releaseFrame(r6, 1, r5); - gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot; - r4->recv.state = SLOT_STATE_RECV_SUCCESS; + NI_comm = &slotStatusNI->recv; + if (NI_comm->dataType == 1) + gRfuLinkStatus->getNameFlag |= 1 << i; + rfu_STC_releaseFrame(i, 1, NI_comm); + gRfuLinkStatus->recvSlotNIFlag &= ~NI_comm->bmSlot; + slotStatusNI->recv.state = SLOT_STATE_RECV_SUCCESS; } } if (gRfuStatic->recvErrorFlag) - r7 = gRfuStatic->recvErrorFlag | ERR_DATA_RECV; + reqResult = gRfuStatic->recvErrorFlag | ERR_DATA_RECV; } - rfu_STC_REQ_callback(r9, r7); + rfu_STC_REQ_callback(reqCommand, reqResult); } static void rfu_STC_PARENT_analyzeRecvPacket(void) { - u32 r3; - u8 r5; - u8 sp[4]; - u8 *r6; + u32 frames32; + u8 bm_slot_id; + u8 frame_counts[RFU_CHILD_MAX]; + u8 *packet_p; - r3 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8; - for (r5 = 0; r5 < NELEMS(sp); ++r5) + frames32 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8; + for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id) { - sp[r5] = r3 & 0x1F; - r3 >>= 5; - if (sp[r5] == 0) - gRfuStatic->NIEndRecvFlag |= 1 << r5; + frame_counts[bm_slot_id] = frames32 & 0x1F; + frames32 >>= 5; + if (frame_counts[bm_slot_id] == 0) + gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id; } - r6 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; - for (r5 = 0; r5 < NELEMS(sp); ++r5) + packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; + for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id) { - if (sp[r5]) + if (frame_counts[bm_slot_id]) { - u8 *r4 = &sp[r5]; + u8 *frames_p = &frame_counts[bm_slot_id]; do { - u8 r0 = rfu_STC_analyzeLLSF(r5, r6, *r4); + u8 analyzed_frames = rfu_STC_analyzeLLSF(bm_slot_id, packet_p, *frames_p); - r6 += r0; - *r4 -= r0; - } while (!(*r4 & 0x80) && (*r4)); + packet_p += analyzed_frames; + *frames_p -= analyzed_frames; + } while (!(*frames_p & 0x80) && (*frames_p)); } } } static void rfu_STC_CHILD_analyzeRecvPacket(void) { - u16 r4; - u8 *r5; - u16 r0; + u16 frames_remaining; + u8 *packet_p; + u16 analyzed_frames; - r4 = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F; - r5 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; - if (r4 == 0) + frames_remaining = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F; + packet_p = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; + if (frames_remaining == 0) gRfuStatic->NIEndRecvFlag = 15; do { - if (r4 == 0) + if (frames_remaining == 0) break; - r0 = rfu_STC_analyzeLLSF(0, r5, r4); - r5 += r0; - r4 -= r0; - } while (!(r4 & 0x8000)); -} - -static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) -{ - struct RfuLocalStruct sp00; - const struct LLSFStruct *r6; - u32 r5; - u8 r4; - u32 r0; - u16 r10; - - r6 = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)]; - if (r3 < r6->unk00) - return r3; - r5 = 0; - for (r4 = 0; r4 < r6->unk00; ++r4) - r5 |= *r7++ << 8 * r4; - sp00.unk00 = (r5 >> r6->unk01) & r6->unk07; - sp00.unk01 = (r5 >> r6->unk02) & r6->unk08; - sp00.unk02 = (r5 >> r6->unk03) & r6->unk09; - sp00.unk03 = (r5 >> r6->unk04) & r6->unk0A; - sp00.unk04 = (r5 >> r6->unk05) & r6->unk0B; - sp00.unk05 = (r5 >> r6->unk06) & r6->unk0C; - sp00.unk06 = (r5 & r6->unk0E) & r5; - r10 = sp00.unk06 + r6->unk00; - if (sp00.unk00 == 0) + analyzed_frames = rfu_STC_analyzeLLSF(0, packet_p, frames_remaining); + packet_p += analyzed_frames; + frames_remaining -= analyzed_frames; + } while (!(frames_remaining & 0x8000)); +} + +static u16 rfu_STC_analyzeLLSF(u8 slot_id, const u8 *src, u16 last_frame) +{ + struct RfuLocalStruct llsf_NI; + const struct LLSFStruct *llsf_p; + u32 frames; + u8 i; + u16 retVal; + + llsf_p = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)]; + if (last_frame < llsf_p->frameSize) + return last_frame; + frames = 0; + for (i = 0; i < llsf_p->frameSize; ++i) + frames |= *src++ << 8 * i; + llsf_NI.recvFirst = (frames >> llsf_p->recvFirstShift) & llsf_p->recvFirstMask; + llsf_NI.connSlotFlag = (frames >> llsf_p->connSlotFlagShift) & llsf_p->connSlotFlagMask; + llsf_NI.slotState = (frames >> llsf_p->slotStateShift) & llsf_p->slotStateMask; + llsf_NI.ack = (frames >> llsf_p->ackShift) & llsf_p->ackMask; + llsf_NI.phase = (frames >> llsf_p->phaseShit) & llsf_p->phaseMask; + llsf_NI.n = (frames >> llsf_p->nShift) & llsf_p->nMask; + llsf_NI.frame = (frames & llsf_p->framesMask) & frames; + retVal = llsf_NI.frame + llsf_p->frameSize; + if (llsf_NI.recvFirst == 0) { if (gRfuLinkStatus->parentChild == MODE_PARENT) { - if ((gRfuLinkStatus->connSlotFlag >> r12) & 1) + if ((gRfuLinkStatus->connSlotFlag >> slot_id) & 1) { - if (sp00.unk02 == 4) + if (llsf_NI.slotState == LCOM_UNI) { - rfu_STC_UNI_receive(r12, &sp00, r7); + rfu_STC_UNI_receive(slot_id, &llsf_NI, src); } - else if (sp00.unk03 == 0) + else if (llsf_NI.ack == 0) { - rfu_STC_NI_receive_Receiver(r12, &sp00, r7); + rfu_STC_NI_receive_Receiver(slot_id, &llsf_NI, src); } else { - for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) - if (((gRfuSlotStatusNI[r4]->send.bmSlot >> r12) & 1) - && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1)) + for (i = 0; i < RFU_CHILD_MAX; ++i) + if (((gRfuSlotStatusNI[i]->send.bmSlot >> slot_id) & 1) + && ((gRfuLinkStatus->sendSlotNIFlag >> slot_id) & 1)) break; - if (r4 <= 3) - rfu_STC_NI_receive_Sender(r4, r12, &sp00, r7); + if (i < RFU_CHILD_MAX) + rfu_STC_NI_receive_Sender(i, slot_id, &llsf_NI, src); } } } else { - s32 r5 = gRfuLinkStatus->connSlotFlag & sp00.unk01; + s32 conSlots = gRfuLinkStatus->connSlotFlag & llsf_NI.connSlotFlag; - if (r5) + if (conSlots) { - for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - if ((r5 >> r4) & 1) + if ((conSlots >> i) & 1) { - if (sp00.unk02 == 4) - rfu_STC_UNI_receive(r4, &sp00, r7); - else if (sp00.unk03 == 0) - rfu_STC_NI_receive_Receiver(r4, &sp00, r7); - else if ((gRfuLinkStatus->sendSlotNIFlag >> r4) & 1) - rfu_STC_NI_receive_Sender(r4, r4, &sp00, r7); + if (llsf_NI.slotState == LCOM_UNI) + rfu_STC_UNI_receive(i, &llsf_NI, src); + else if (llsf_NI.ack == 0) + rfu_STC_NI_receive_Receiver(i, &llsf_NI, src); + else if ((gRfuLinkStatus->sendSlotNIFlag >> i) & 1) + rfu_STC_NI_receive_Sender(i, i, &llsf_NI, src); } } } } } - return r10; + return retVal; } -static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 *sp00) +static void rfu_STC_UNI_receive(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *src) { - u8 *sp04; - u32 r2; - struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7]; - struct UNIRecv *r5 = &r3->recv; + u8 *dest; + u32 size; + struct RfuSlotStatusUNI *slotStatusUNI = gRfuSlotStatusUNI[bm_slot_id]; + struct UNIRecv *UNI_recv = &slotStatusUNI->recv; - r5->errorCode = 0; - if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06) + UNI_recv->errorCode = 0; + if (gRfuSlotStatusUNI[bm_slot_id]->recvBufferSize < llsf_NI->frame) { - r3->recv.state = SLOT_STATE_RECV_IGNORE; - r5->errorCode = ERR_RECV_BUFF_OVER; + slotStatusUNI->recv.state = SLOT_STATE_RECV_IGNORE; + UNI_recv->errorCode = ERR_RECV_BUFF_OVER; } else - { - if (r5->dataBlockFlag) + { + if (UNI_recv->dataBlockFlag) { - if (r5->newDataFlag) + if (UNI_recv->newDataFlag) { - r5->errorCode = ERR_RECV_UNK; - goto _081E2F0E; + UNI_recv->errorCode = ERR_RECV_UNK; + goto force_tail_merge; } } else { - if (r5->newDataFlag) - r5->errorCode = ERR_RECV_DATA_OVERWRITED; + if (UNI_recv->newDataFlag) + UNI_recv->errorCode = ERR_RECV_DATA_OVERWRITED; } - r5->state = SLOT_STATE_RECEIVING; - r2 = r5->dataSize = r6->unk06; - sp04 = gRfuSlotStatusUNI[r7]->recvBuffer; - gRfuFixed->fastCopyPtr(&sp00, &sp04, r2); - r5->newDataFlag = 1; - r5->state = 0; + UNI_recv->state = SLOT_STATE_RECEIVING; + size = UNI_recv->dataSize = llsf_NI->frame; + dest = gRfuSlotStatusUNI[bm_slot_id]->recvBuffer; + gRfuFixed->fastCopyPtr(&src, &dest, size); + UNI_recv->newDataFlag = 1; + UNI_recv->state = 0; } -_081E2F0E: - if (r5->errorCode) - gRfuStatic->recvErrorFlag |= 16 << r7; +force_tail_merge: + if (UNI_recv->errorCode) + gRfuStatic->recvErrorFlag |= 16 << bm_slot_id; } -static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct *r6, const u8 *r3) +static void rfu_STC_NI_receive_Sender(u8 NI_slot, u8 bm_flag, const struct RfuLocalStruct *llsf_NI, const u8 *data_p) { - struct NIComm *r12 = &gRfuSlotStatusNI[r0]->send; - u16 r9 = r12->state; - u8 sp00 = r12->n[r6->unk04]; - u8 *r8; - u8 r4; - u16 r2; + struct NIComm *NI_comm = &gRfuSlotStatusNI[NI_slot]->send; + u16 state = NI_comm->state; + u8 n = NI_comm->n[llsf_NI->phase]; + u8 i; + u16 imeBak; - if ((r6->unk02 == 2 && r9 == SLOT_STATE_SENDING) - || (r6->unk02 == 1 && r9 == SLOT_STATE_SEND_START) - || (r6->unk02 == 3 && r9 == SLOT_STATE_SEND_LAST)) + if ((llsf_NI->slotState == LCOM_NI && state == SLOT_STATE_SENDING) + || (llsf_NI->slotState == LCOM_NI_START && state == SLOT_STATE_SEND_START) + || (llsf_NI->slotState == LCOM_NI_END && state == SLOT_STATE_SEND_LAST)) { - if (r12->n[r6->unk04] == r6->unk05) - r12->recvAckFlag[r6->unk04] |= 1 << r10; + if (NI_comm->n[llsf_NI->phase] == llsf_NI->n) + NI_comm->recvAckFlag[llsf_NI->phase] |= 1 << bm_flag; } - if ((r12->recvAckFlag[r6->unk04] & r12->bmSlot) == r12->bmSlot) + if ((NI_comm->recvAckFlag[llsf_NI->phase] & NI_comm->bmSlot) == NI_comm->bmSlot) { - r12->n[r6->unk04] = (r12->n[r6->unk04] + 1) & 3; - r12->recvAckFlag[r6->unk04] = 0; - if ((u16)(r12->state + ~SLOT_STATE_SEND_NULL) <= 1) + NI_comm->n[llsf_NI->phase] = (NI_comm->n[llsf_NI->phase] + 1) & 3; + NI_comm->recvAckFlag[llsf_NI->phase] = 0; + if ((u16)(NI_comm->state + ~SLOT_STATE_SEND_NULL) <= 1) { - if (r12->state == SLOT_STATE_SEND_START) - r12->now_p[r6->unk04] += r12->payloadSize; + if (NI_comm->state == SLOT_STATE_SEND_START) + NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize; else - r12->now_p[r6->unk04] += r12->payloadSize << 2; - r12->remainSize -= r12->payloadSize; - if (r12->remainSize != 0) - if (r12->remainSize >= 0) + NI_comm->now_p[llsf_NI->phase] += NI_comm->payloadSize << 2; + NI_comm->remainSize -= NI_comm->payloadSize; + if (NI_comm->remainSize != 0) + if (NI_comm->remainSize >= 0) goto _081E30AE; - // Above is a hack to avoid optimization over comparison. - // rfu_STC_NI_constructLLSF uses this field as u32. - // It's equivalent to the following condition: - // if (r12->remainSize == 0 || r12->remainSize < 0) - { - r12->phase = 0; - if (r12->state == SLOT_STATE_SEND_START) + // Above is a hack to avoid optimization over comparison. + // rfu_STC_NI_constructLLSF uses this field as u32. + // It's equivalent to the following condition: + // if (NI_comm->remainSize == 0 || NI_comm->remainSize < 0) { - for (r4 = 0; r4 < WINDOW_COUNT; ++r4) + NI_comm->phase = 0; + if (NI_comm->state == SLOT_STATE_SEND_START) + { + for (i = 0; i < WINDOW_COUNT; ++i) + { + NI_comm->n[i] = 1; + NI_comm->now_p[i] = NI_comm->src + NI_comm->payloadSize * i; + } + NI_comm->remainSize = NI_comm->dataSize; + NI_comm->state = SLOT_STATE_SENDING; + } + else { - r12->n[r4] = 1; - r12->now_p[r4] = r12->src + r12->payloadSize * r4; + NI_comm->n[0] = 0; + NI_comm->remainSize = 0; + NI_comm->state = SLOT_STATE_SEND_LAST; } - r12->remainSize = r12->dataSize; - r12->state = SLOT_STATE_SENDING; } - else - { - r12->n[0] = 0; - r12->remainSize = 0; - r12->state = SLOT_STATE_SEND_LAST; - } - } _081E30AE: + ; } - else if (r12->state == SLOT_STATE_SEND_LAST) + else if (NI_comm->state == SLOT_STATE_SEND_LAST) { - r12->state = SLOT_STATE_SEND_NULL; + NI_comm->state = SLOT_STATE_SEND_NULL; } } - if (r12->state != r9 - || r12->n[r6->unk04] != sp00 - || (r12->recvAckFlag[r6->unk04] >> r10) & 1) + if (NI_comm->state != state + || NI_comm->n[llsf_NI->phase] != n + || (NI_comm->recvAckFlag[llsf_NI->phase] >> bm_flag) & 1) { - r2 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - gRfuStatic->recvRenewalFlag |= 16 << r10; - gRfuSlotStatusNI[r10]->send.failCounter = 0; - REG_IME = r2; + gRfuStatic->recvRenewalFlag |= 16 << bm_flag; + gRfuSlotStatusNI[bm_flag]->send.failCounter = 0; + REG_IME = imeBak; } } -static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, const u8 *sp00) +static void rfu_STC_NI_receive_Receiver(u8 bm_slot_id, const struct RfuLocalStruct *llsf_NI, const u8 *data_p) { - u16 r2; - u32 r7 = 0; - struct RfuSlotStatusNI *r4 = gRfuSlotStatusNI[r8]; - struct NIComm *r5 = &r4->recv; - u16 r9 = r4->recv.state; - u8 r10 = r4->recv.n[r6->unk04]; + u16 imeBak; + u32 state_check = 0; + struct RfuSlotStatusNI *slotStatus_NI = gRfuSlotStatusNI[bm_slot_id]; + struct NIComm *recvSlot = &slotStatus_NI->recv; + u16 state = slotStatus_NI->recv.state; + u8 n = slotStatus_NI->recv.n[llsf_NI->phase]; - if (r6->unk02 == 3) + if (llsf_NI->slotState == LCOM_NI_END) { - gRfuStatic->NIEndRecvFlag |= 1 << r8; - if (r4->recv.state == SLOT_STATE_RECEIVING) + gRfuStatic->NIEndRecvFlag |= 1 << bm_slot_id; + if (slotStatus_NI->recv.state == SLOT_STATE_RECEIVING) { - r4->recv.phase = 0; - r4->recv.n[0] = 0; - r4->recv.state = SLOT_STATE_RECV_LAST; + slotStatus_NI->recv.phase = 0; + slotStatus_NI->recv.n[0] = 0; + slotStatus_NI->recv.state = SLOT_STATE_RECV_LAST; } } - else if (r6->unk02 == 2) + else if (llsf_NI->slotState == LCOM_NI) { - if (r9 == SLOT_STATE_RECV_START && !r5->remainSize) - rfu_STC_NI_initSlot_asRecvDataEntity(r8, r5); - if (r5->state == SLOT_STATE_RECEIVING) - r7 = 1; + if (state == SLOT_STATE_RECV_START && !recvSlot->remainSize) + rfu_STC_NI_initSlot_asRecvDataEntity(bm_slot_id, recvSlot); + if (recvSlot->state == SLOT_STATE_RECEIVING) + state_check = 1; } - else if (r6->unk02 == 1) + else if (llsf_NI->slotState == LCOM_NI_START) { - if (r9 == SLOT_STATE_RECV_START) + if (state == SLOT_STATE_RECV_START) { - r7 = 1; + state_check = 1; } else { - rfu_STC_NI_initSlot_asRecvControllData(r8, r5); - if (r4->recv.state != SLOT_STATE_RECV_START) + rfu_STC_NI_initSlot_asRecvControllData(bm_slot_id, recvSlot); + if (slotStatus_NI->recv.state != SLOT_STATE_RECV_START) return; - r7 = 1; + state_check = 1; } } - if (r7 != 0) + if (state_check != 0) { - if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3)) + if (llsf_NI->n == ((recvSlot->n[llsf_NI->phase] + 1) & 3)) { - gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->now_p[r6->unk04], r6->unk06); - if (r5->state == SLOT_STATE_RECEIVING) - r5->now_p[r6->unk04] += 3 * r5->payloadSize; - r5->remainSize -= r6->unk06; - r5->n[r6->unk04] = r6->unk05; + gRfuFixed->fastCopyPtr(&data_p, (u8 **)&recvSlot->now_p[llsf_NI->phase], llsf_NI->frame); + if (recvSlot->state == SLOT_STATE_RECEIVING) + recvSlot->now_p[llsf_NI->phase] += 3 * recvSlot->payloadSize; + recvSlot->remainSize -= llsf_NI->frame; + recvSlot->n[llsf_NI->phase] = llsf_NI->n; } } - if (r5->errorCode == 0) + if (recvSlot->errorCode == 0) { - r5->phase = r6->unk04; - if (r5->state != r9 || r5->n[r6->unk04] != r10 || r5->n[r6->unk04] == r6->unk05) + recvSlot->phase = llsf_NI->phase; + if (recvSlot->state != state || recvSlot->n[llsf_NI->phase] != n || recvSlot->n[llsf_NI->phase] == llsf_NI->n) { - r2 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - gRfuStatic->recvRenewalFlag |= 1 << r8; - r5->failCounter = 0; - REG_IME = r2; + gRfuStatic->recvRenewalFlag |= 1 << bm_slot_id; + recvSlot->failCounter = 0; + REG_IME = imeBak; } } } -static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) +static void rfu_STC_NI_initSlot_asRecvControllData(u8 bm_slot_id, struct NIComm *NI_comm) { - u8 *r1; - u32 r5; - u8 r6; + u8 *llFrameSize_p; + u32 llFrameSize; + u8 bm_slot_flag; if (gRfuLinkStatus->parentChild == MODE_PARENT) { - r5 = 3; - r1 = &gRfuLinkStatus->remainLLFrameSizeParent; + llFrameSize = 3; + llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeParent; } else { - r5 = 2; - r1 = &gRfuLinkStatus->remainLLFrameSizeChild[r4]; + llFrameSize = 2; + llFrameSize_p = &gRfuLinkStatus->remainLLFrameSizeChild[bm_slot_id]; } - r6 = 1 << r4; - if (r2->state == 0) + bm_slot_flag = 1 << bm_slot_id; + if (NI_comm->state == 0) { - if (*r1 < r5) + if (*llFrameSize_p < llFrameSize) { - r2->state = SLOT_STATE_RECV_IGNORE; - r2->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE; - gRfuStatic->recvErrorFlag |= r6; + NI_comm->state = SLOT_STATE_RECV_IGNORE; + NI_comm->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE; + gRfuStatic->recvErrorFlag |= bm_slot_flag; } else { - r2->errorCode = 0; - *r1 -= r5; - r2->now_p[0] = &r2->dataType; - r2->remainSize = 7; - r2->ack = 1; - r2->payloadSize = 0; - r2->bmSlot = r6; - r2->state = SLOT_STATE_RECV_START; - gRfuLinkStatus->recvSlotNIFlag |= r6; + NI_comm->errorCode = 0; + *llFrameSize_p -= llFrameSize; + NI_comm->now_p[0] = &NI_comm->dataType; + NI_comm->remainSize = 7; + NI_comm->ack = 1; + NI_comm->payloadSize = 0; + NI_comm->bmSlot = bm_slot_flag; + NI_comm->state = SLOT_STATE_RECV_START; + gRfuLinkStatus->recvSlotNIFlag |= bm_slot_flag; } } } -static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4) +static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 bm_slot_id, struct NIComm *NI_comm) { - u8 r1, r3; + u8 bm_slot_flag, win_id; - if (r4->dataType == 1) + if (NI_comm->dataType == 1) { - r4->now_p[0] = (void *)&gRfuLinkStatus->partner[r5].serialNo; + NI_comm->now_p[0] = (void *)&gRfuLinkStatus->partner[bm_slot_id].serialNo; } else { - if (r4->dataSize > gRfuSlotStatusNI[r5]->recvBufferSize) + if (NI_comm->dataSize > gRfuSlotStatusNI[bm_slot_id]->recvBufferSize) { - r1 = 1 << r5; - gRfuStatic->recvErrorFlag |= r1; - gRfuLinkStatus->recvSlotNIFlag &= ~r1; - r4->errorCode = ERR_RECV_BUFF_OVER; - r4->state = SLOT_STATE_RECV_FAILED; - rfu_STC_releaseFrame(r5, 1, r4); + bm_slot_flag = 1 << bm_slot_id; + gRfuStatic->recvErrorFlag |= bm_slot_flag; + gRfuLinkStatus->recvSlotNIFlag &= ~bm_slot_flag; + NI_comm->errorCode = ERR_RECV_BUFF_OVER; + NI_comm->state = SLOT_STATE_RECV_FAILED; + rfu_STC_releaseFrame(bm_slot_id, 1, NI_comm); return; } - r4->now_p[0] = gRfuSlotStatusNI[r5]->recvBuffer; + NI_comm->now_p[0] = gRfuSlotStatusNI[bm_slot_id]->recvBuffer; } - for (r3 = 0; r3 < WINDOW_COUNT; ++r3) + for (win_id = 0; win_id < WINDOW_COUNT; ++win_id) { - r4->n[r3] = 0; - r4->now_p[r3] = &r4->now_p[0][r4->payloadSize * r3]; + NI_comm->n[win_id] = 0; + NI_comm->now_p[win_id] = &NI_comm->now_p[0][NI_comm->payloadSize * win_id]; } - r4->remainSize = r4->dataSize; - r4->state = SLOT_STATE_RECEIVING; + NI_comm->remainSize = NI_comm->dataSize; + NI_comm->state = SLOT_STATE_RECEIVING; } static void rfu_NI_checkCommFailCounter(void) { - u16 r12; - u32 r7; - u8 r2, r3; + u16 imeBak; + u32 recvRenewalFlag; + u8 bm_slot_flag, bm_slot_id; if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag) { - r12 = REG_IME; + imeBak = REG_IME; REG_IME = 0; - r7 = gRfuStatic->recvRenewalFlag >> 4; - for (r3 = 0; r3 < RFU_CHILD_MAX; ++r3) + recvRenewalFlag = gRfuStatic->recvRenewalFlag >> 4; + for (bm_slot_id = 0; bm_slot_id < RFU_CHILD_MAX; ++bm_slot_id) { - r2 = 1 << r3; - if (gRfuLinkStatus->sendSlotNIFlag & r2 - && !(gRfuStatic->recvRenewalFlag & r2)) - ++gRfuSlotStatusNI[r3]->send.failCounter; - if (gRfuLinkStatus->recvSlotNIFlag & r2 - && !(r7 & r2)) - ++gRfuSlotStatusNI[r3]->recv.failCounter; + bm_slot_flag = 1 << bm_slot_id; + if (gRfuLinkStatus->sendSlotNIFlag & bm_slot_flag + && !(gRfuStatic->recvRenewalFlag & bm_slot_flag)) + ++gRfuSlotStatusNI[bm_slot_id]->send.failCounter; + if (gRfuLinkStatus->recvSlotNIFlag & bm_slot_flag + && !(recvRenewalFlag & bm_slot_flag)) + ++gRfuSlotStatusNI[bm_slot_id]->recv.failCounter; } gRfuStatic->recvRenewalFlag = 0; - REG_IME = r12; + REG_IME = imeBak; } } diff --git a/src/librfu_sio32id.c b/src/librfu_sio32id.c index fc5701986..b6623540f 100644 --- a/src/librfu_sio32id.c +++ b/src/librfu_sio32id.c @@ -4,44 +4,56 @@ static void Sio32IDIntr(void); static void Sio32IDInit(void); static s32 Sio32IDMain(void); +struct RfuSIO32Id +{ + u8 MS_mode; + u8 state; + u16 count; + u16 send_id; + u16 recv_id; + u16 unk8; // unused + u16 lastId; +}; + struct RfuSIO32Id gRfuSIO32Id; static const u16 Sio32ConnectionData[] = { 0x494e, 0x544e, 0x4e45, 0x4f44 }; // NINTENDO static const char Sio32IDLib_Var[] = "Sio32ID_030820"; -s32 AgbRFU_checkID(u8 r5) +s32 AgbRFU_checkID(u8 maxTries) { - u16 r8; - vu16 *r4; - s32 r6; + u16 ieBak; + vu16 *regTMCNTL; + s32 id; + // Interrupts must be enabled if (REG_IME == 0) return -1; - r8 = REG_IE; + ieBak = REG_IE; gSTWIStatus->state = 10; STWI_set_Callback_ID(Sio32IDIntr); Sio32IDInit(); - r4 = ®_TMCNT_L(gSTWIStatus->timerSelect); - r5 *= 8; - while (--r5 != 0xFF) + regTMCNTL = ®_TMCNT_L(gSTWIStatus->timerSelect); + maxTries *= 8; + while (--maxTries != 0xFF) { - r6 = Sio32IDMain(); - if (r6 != 0) + id = Sio32IDMain(); + if (id != 0) break; - r4[1] = 0; - r4[0] = 0; - r4[1] = TIMER_1024CLK | TIMER_ENABLE; - while (r4[0] < 32) + regTMCNTL[1] = 0; + regTMCNTL[0] = 0; + regTMCNTL[1] = TIMER_1024CLK | TIMER_ENABLE; + while (regTMCNTL[0] < 32) ; - r4[1] = 0; - r4[0] = 0; + regTMCNTL[1] = 0; + regTMCNTL[0] = 0; } REG_IME = 0; - REG_IE = r8; + REG_IE = ieBak; REG_IME = 1; gSTWIStatus->state = 0; STWI_set_Callback_ID(NULL); - return r6; + return id; } static void Sio32IDInit(void) @@ -58,107 +70,105 @@ static void Sio32IDInit(void) static s32 Sio32IDMain(void) { - u8 r12; - - switch (r12 = gRfuSIO32Id.unk1) + switch (gRfuSIO32Id.state) { case 0: - gRfuSIO32Id.unk0 = 1; + gRfuSIO32Id.MS_mode = AGB_CLK_MASTER; REG_SIOCNT |= SIO_38400_BPS; - REG_IME = r12; + REG_IME = 0; REG_IE |= INTR_FLAG_SERIAL; REG_IME = 1; - gRfuSIO32Id.unk1 = 1; + gRfuSIO32Id.state = 1; *(vu8 *)®_SIOCNT |= SIO_ENABLE; break; case 1: - if (gRfuSIO32Id.unkA == 0) + if (gRfuSIO32Id.lastId == 0) { - if (gRfuSIO32Id.unk0 == 1) + if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER) { - if (gRfuSIO32Id.unk2 == 0) + if (gRfuSIO32Id.count == 0) { - REG_IME = gRfuSIO32Id.unk2; + REG_IME = 0; REG_SIOCNT |= SIO_ENABLE; - REG_IME = r12; + REG_IME = 1; } } - else if (gRfuSIO32Id.unk4 != 0x8001 && !gRfuSIO32Id.unk2) + else if (gRfuSIO32Id.send_id != RFU_ID && !gRfuSIO32Id.count) { - REG_IME = gRfuSIO32Id.unk2; + REG_IME = 0; REG_IE &= ~INTR_FLAG_SERIAL; - REG_IME = r12; - REG_SIOCNT = gRfuSIO32Id.unk2; + REG_IME = 1; + REG_SIOCNT = 0; REG_SIOCNT = SIO_32BIT_MODE; REG_IF = INTR_FLAG_SERIAL; REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; - REG_IME = gRfuSIO32Id.unk2; + REG_IME = 0; REG_IE |= INTR_FLAG_SERIAL; - REG_IME = r12; + REG_IME = 1; } break; } else { - gRfuSIO32Id.unk1 = 2; + gRfuSIO32Id.state = 2; // fallthrough } default: - return gRfuSIO32Id.unkA; + return gRfuSIO32Id.lastId; } return 0; } static void Sio32IDIntr(void) { - u32 r5; - u16 r0; + u32 regSIODATA32; + u16 delay; #ifndef NONMATCHING - register u32 r1 asm("r1"); - register u16 r0_ asm("r0"); + register u32 rfuSIO32IdUnk0_times_16 asm("r1"); + register u16 negRfuSIO32IdUnk6 asm("r0"); #else - u32 r1; - u16 r0_; + u32 rfuSIO32IdUnk0_times_16; + u16 negRfuSIO32IdUnk6; #endif - r5 = REG_SIODATA32; - if (gRfuSIO32Id.unk0 != 1) + regSIODATA32 = REG_SIODATA32; + if (gRfuSIO32Id.MS_mode != AGB_CLK_MASTER) REG_SIOCNT |= SIO_ENABLE; - r1 = 16 * gRfuSIO32Id.unk0; // to handle side effect of inline asm - r1 = (r5 << r1) >> 16; - r5 = (r5 << 16 * (1 - gRfuSIO32Id.unk0)) >> 16; - if (gRfuSIO32Id.unkA == 0) + rfuSIO32IdUnk0_times_16 = 16 * gRfuSIO32Id.MS_mode; // to handle side effect of inline asm + rfuSIO32IdUnk0_times_16 = (regSIODATA32 << rfuSIO32IdUnk0_times_16) >> 16; + regSIODATA32 = (regSIODATA32 << 16 * (1 - gRfuSIO32Id.MS_mode)) >> 16; + if (gRfuSIO32Id.lastId == 0) { - if (r1 == gRfuSIO32Id.unk6) + if (rfuSIO32IdUnk0_times_16 == gRfuSIO32Id.recv_id) { - if (gRfuSIO32Id.unk2 > 3) + if (gRfuSIO32Id.count > 3) { - gRfuSIO32Id.unkA = r5; + gRfuSIO32Id.lastId = regSIODATA32; } - else if (r1 == (u16)~gRfuSIO32Id.unk4) + else if (rfuSIO32IdUnk0_times_16 == (u16)~gRfuSIO32Id.send_id) { - r0_ = ~gRfuSIO32Id.unk6; - if (r5 == r0_) - ++gRfuSIO32Id.unk2; + negRfuSIO32IdUnk6 = ~gRfuSIO32Id.recv_id; + if (regSIODATA32 == negRfuSIO32IdUnk6) + ++gRfuSIO32Id.count; } } else { - gRfuSIO32Id.unk2 = gRfuSIO32Id.unkA; + gRfuSIO32Id.count = 0; } } - if (gRfuSIO32Id.unk2 < 4) - gRfuSIO32Id.unk4 = *(gRfuSIO32Id.unk2 + Sio32ConnectionData); + if (gRfuSIO32Id.count < 4) + gRfuSIO32Id.send_id = *(gRfuSIO32Id.count + Sio32ConnectionData); else - gRfuSIO32Id.unk4 = 0x8001; - gRfuSIO32Id.unk6 = ~r5; - REG_SIODATA32 = (gRfuSIO32Id.unk4 << 16 * (1 - gRfuSIO32Id.unk0)) - + (gRfuSIO32Id.unk6 << 16 * gRfuSIO32Id.unk0); - if (gRfuSIO32Id.unk0 == 1 && (gRfuSIO32Id.unk2 || r5 == 0x494E)) + gRfuSIO32Id.send_id = RFU_ID; + gRfuSIO32Id.recv_id = ~regSIODATA32; + REG_SIODATA32 = (gRfuSIO32Id.send_id << 16 * (1 - gRfuSIO32Id.MS_mode)) + + (gRfuSIO32Id.recv_id << 16 * gRfuSIO32Id.MS_mode); + if (gRfuSIO32Id.MS_mode == AGB_CLK_MASTER && (gRfuSIO32Id.count != 0 || regSIODATA32 == 0x494e)) { - for (r0 = 0; r0 < 600; ++r0) + for (delay = 0; delay < 600; ++delay) ; - if (gRfuSIO32Id.unkA == 0) + if (gRfuSIO32Id.lastId == 0) REG_SIOCNT |= SIO_ENABLE; } } diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index b88f21737..0287b358a 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -28,8 +28,8 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b } gSTWIStatus->rxPacket = &interruptStruct->rxPacketAlloc; gSTWIStatus->txPacket = &interruptStruct->txPacketAlloc; - gSTWIStatus->msMode = 1; - gSTWIStatus->state = 0; + gSTWIStatus->msMode = AGB_CLK_MASTER; + gSTWIStatus->state = 0; // master send req gSTWIStatus->reqLength = 0; gSTWIStatus->reqNext = 0; gSTWIStatus->ackLength = 0; @@ -39,7 +39,7 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b gSTWIStatus->timerActive = 0; gSTWIStatus->error = 0; gSTWIStatus->recoveryCount = 0; - gSTWIStatus->unk_2c = 0; + gSTWIStatus->sending = 0; REG_RCNT = 0x100; // TODO: mystery bit? REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; STWI_init_Callback_M(); @@ -71,7 +71,7 @@ void AgbRFU_SoftReset(void) *timerH = 3; REG_RCNT = 0x80A0; REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; - gSTWIStatus->state = 0; + gSTWIStatus->state = 0; // master send req gSTWIStatus->reqLength = 0; gSTWIStatus->reqNext = 0; gSTWIStatus->reqActiveCommand = 0; @@ -81,9 +81,9 @@ void AgbRFU_SoftReset(void) gSTWIStatus->timerState = 0; gSTWIStatus->timerActive = 0; gSTWIStatus->error = 0; - gSTWIStatus->msMode = 1; + gSTWIStatus->msMode = AGB_CLK_MASTER; gSTWIStatus->recoveryCount = 0; - gSTWIStatus->unk_2c = 0; + gSTWIStatus->sending = 0; } void STWI_set_MS_mode(u8 mode) @@ -131,12 +131,12 @@ void STWI_set_Callback_S(void (*callbackS)(u16)) void STWI_set_Callback_ID(void (*func)(void)) // name in SDK, but is actually setting a function pointer { - gSTWIStatus->unk_20 = func; + gSTWIStatus->callbackID = func; } u16 STWI_poll_CommandEnd(void) { - while (gSTWIStatus->unk_2c == TRUE) + while (gSTWIStatus->sending == 1) ; return gSTWIStatus->error; } @@ -195,7 +195,7 @@ void STWI_send_ConfigStatusREQ(void) } } -void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) +void STWI_send_GameConfigREQ(const u8 *serial_gname, const u8 *uname) { u8 *packetBytes; s32 i; @@ -203,29 +203,28 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) if (!STWI_init(ID_GAME_CONFIG_REQ)) { gSTWIStatus->reqLength = 6; - // TODO: what is unk1 packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); - *(u16 *)packetBytes = *(u16 *)unk1; + *(u16 *)packetBytes = *(u16 *)serial_gname; packetBytes += sizeof(u16); - unk1 += sizeof(u16); + serial_gname += sizeof(u16); for (i = 0; i < 14; ++i) { - *packetBytes = *unk1; + *packetBytes = *serial_gname; ++packetBytes; - ++unk1; + ++serial_gname; } for (i = 0; i < 8; ++i) { - *packetBytes = *data; + *packetBytes = *uname; ++packetBytes; - ++data; + ++uname; } STWI_start_Command(); } } -void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) +void STWI_send_SystemConfigREQ(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer) { if (!STWI_init(ID_SYSTEM_CONFIG_REQ)) { @@ -234,9 +233,9 @@ void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) gSTWIStatus->reqLength = 1; packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); - *packetBytes++ = unk3; - *packetBytes++ = unk2; - *(u16*)packetBytes = unk1; + *packetBytes++ = mcTimer; + *packetBytes++ = maxMFrame; + *(u16*)packetBytes = availSlotFlag; STWI_start_Command(); } } @@ -499,20 +498,17 @@ static void STWI_intr_timer(void) STWI_stop_timer(); STWI_reset_ClockCounter(); if (gSTWIStatus->callbackM != NULL) - gSTWIStatus->callbackM(255, 0); + gSTWIStatus->callbackM(ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ, 0); break; } } -static void STWI_set_timer(u8 unk) +static void STWI_set_timer(u8 count) { - vu16 *timerL; - vu16 *timerH; - - timerL = ®_TMCNT_L(gSTWIStatus->timerSelect); - timerH = ®_TMCNT_H(gSTWIStatus->timerSelect); + vu16 *timerL = ®_TMCNT_L(gSTWIStatus->timerSelect); + vu16 *timerH = ®_TMCNT_H(gSTWIStatus->timerSelect); REG_IME = 0; - switch (unk) + switch (count) { case 50: *timerL = 0xFCCB; @@ -543,25 +539,31 @@ static void STWI_stop_timer(void) REG_TMCNT_H(gSTWIStatus->timerSelect) = 0; } +/* + * Set up STWI to send REQ. Returns 1 if error (see below). + */ static u16 STWI_init(u8 request) { if (!REG_IME) { + // Can't start sending if IME is disabled. gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE; if (gSTWIStatus->callbackM != NULL) gSTWIStatus->callbackM(request, gSTWIStatus->error); return TRUE; } - else if (gSTWIStatus->unk_2c == TRUE) + else if (gSTWIStatus->sending == 1) { + // Already sending something. Cancel and error. gSTWIStatus->error = ERR_REQ_CMD_SENDING; - gSTWIStatus->unk_2c = FALSE; + gSTWIStatus->sending = 0; if (gSTWIStatus->callbackM != NULL) gSTWIStatus->callbackM(request, gSTWIStatus->error); return TRUE; } - else if(!gSTWIStatus->msMode) + else if (gSTWIStatus->msMode == AGB_CLK_SLAVE) { + // Can't send if clock slave gSTWIStatus->error = ERR_REQ_CMD_CLOCK_SLAVE; if (gSTWIStatus->callbackM != NULL) gSTWIStatus->callbackM(request, gSTWIStatus->error, gSTWIStatus); @@ -569,9 +571,10 @@ static u16 STWI_init(u8 request) } else { - gSTWIStatus->unk_2c = TRUE; + // Good to go, start sending + gSTWIStatus->sending = 1; gSTWIStatus->reqActiveCommand = request; - gSTWIStatus->state = 0; + gSTWIStatus->state = 0; // master send req gSTWIStatus->reqLength = 0; gSTWIStatus->reqNext = 0; gSTWIStatus->ackLength = 0; @@ -595,7 +598,7 @@ static s32 STWI_start_Command(void) // but the cast here is required to avoid register issue *(u32 *)gSTWIStatus->txPacket->rfuPacket8.data = 0x99660000 | (gSTWIStatus->reqLength << 8) | gSTWIStatus->reqActiveCommand; REG_SIODATA32 = gSTWIStatus->txPacket->rfuPacket32.command; - gSTWIStatus->state = 0; + gSTWIStatus->state = 0; // master send req gSTWIStatus->reqNext = 1; imeTemp = REG_IME; REG_IME = 0; @@ -608,7 +611,7 @@ static s32 STWI_start_Command(void) static s32 STWI_restart_Command(void) { - if (gSTWIStatus->recoveryCount <= 1) + if (gSTWIStatus->recoveryCount < 2) { ++gSTWIStatus->recoveryCount; STWI_start_Command(); @@ -618,17 +621,17 @@ static s32 STWI_restart_Command(void) if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_UNK35_REQ || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) { gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT; - gSTWIStatus->unk_2c = 0; + gSTWIStatus->sending = 0; if (gSTWIStatus->callbackM != NULL) gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error); } else { gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT; - gSTWIStatus->unk_2c = 0; + gSTWIStatus->sending = 0; if (gSTWIStatus->callbackM != NULL) gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error); - gSTWIStatus->state = 4; // TODO: what's 4 + gSTWIStatus->state = 4; // error } } return 0; @@ -636,7 +639,7 @@ static s32 STWI_restart_Command(void) static s32 STWI_reset_ClockCounter(void) { - gSTWIStatus->state = 5; // TODO: what is 5 + gSTWIStatus->state = 5; // slave receive req init gSTWIStatus->reqLength = 0; gSTWIStatus->reqNext = 0; REG_SIODATA32 = (1 << 31); diff --git a/src/link.c b/src/link.c index dfb21f126..26e223153 100644 --- a/src/link.c +++ b/src/link.c @@ -82,14 +82,14 @@ u32 gFiller_3003EC0; u16 gLinkHeldKeys; u16 gRecvCmds[MAX_RFU_PLAYERS][CMD_LENGTH]; u32 gLinkStatus; -bool8 gUnknown_3003F24; +bool8 gLinkAllAcked5FFF; bool8 gUnknown_3003F28; -bool8 gUnknown_3003F2C[MAX_LINK_PLAYERS]; -bool8 gUnknown_3003F30[MAX_LINK_PLAYERS]; -u16 gUnknown_3003F34; +bool8 gLinkCommand2FFEAck[MAX_LINK_PLAYERS]; +bool8 gLinkCommand5FFFAck[MAX_LINK_PLAYERS]; +u16 gLinkCmd5FFFparam; u8 gSuppressLinkErrorMessage; -bool8 gWirelessCommType; -bool8 gSavedLinkPlayerCount; +u8 gWirelessCommType; +u8 gSavedLinkPlayerCount; u16 gSendCmd[CMD_LENGTH]; u8 gSavedMultiplayerId; bool8 gReceivedRemoteLinkPlayers; @@ -123,8 +123,8 @@ EWRAM_DATA struct { u8 lastSendQueueCount; u8 unk_06; } sLinkErrorBuffer = {}; -EWRAM_DATA u16 gUnknown_202285C = 0; -EWRAM_DATA void *gUnknown_2022860 = NULL; +static EWRAM_DATA u16 sStartSend5FFFfailures = 0; +static EWRAM_DATA void *sLinkErrorBgTilemapBuffer = NULL; static void InitLocalLinkPlayer(void); static void sub_800978C(void); @@ -142,13 +142,13 @@ static u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size); static void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2); static void LinkCB_RequestPlayerDataExchange(void); static void Task_PrintTestData(u8 taskId); -static void sub_800AB0C(void); -static void sub_800AB38(void); -static void sub_800ABD4(void); -static void sub_800AC00(void); +static void LinkCB_BuildCommand5FFF(void); +static void LinkCB_WaitAckCommand5FFF(void); +static void LinkFunc_Send2FFE_1(void); +static void LinkFunc_Send2FFE_2(void); static void CheckErrorStatus(void); static void CB2_PrintErrorMessage(void); -static void sub_800B210(void); +static void SetWirelessCommType0(void); static void DisableSerial(void); static void EnableSerial(void); static bool8 IsSioMultiMaster(void); @@ -232,16 +232,16 @@ bool8 IsWirelessAdapterConnected(void) if (gQuestLogState == 2 || gQuestLogState == 3) return FALSE; - sub_800B1F4(); + SetWirelessCommType1(); sub_80F86F4(); sub_80FB128(TRUE); - if (sub_80FD3A4() == RFU_ID) + if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID) { rfu_REQ_stopMode(); rfu_waitREQComplete(); return TRUE; } - sub_800B210(); + SetWirelessCommType0(); CloseLink(); RestoreSerialTimer3IntrHandlers(); return FALSE; @@ -379,8 +379,8 @@ void OpenLink(void) ResetBlockSend(); gUnknown_3000E4C = 0; gUnknown_3003F28 = FALSE; - gUnknown_3003F24 = FALSE; - gUnknown_3003F34 = 0; + gLinkAllAcked5FFF = FALSE; + gLinkCmd5FFFparam = 0; CreateTask(Task_TriggerHandshake, 2); } else @@ -391,8 +391,8 @@ void OpenLink(void) for (i = 0; i < MAX_LINK_PLAYERS; i++) { gRemoteLinkPlayersNotReceived[i] = TRUE; - gUnknown_3003F30[i] = FALSE; - gUnknown_3003F2C[i] = FALSE; + gLinkCommand5FFFAck[i] = FALSE; + gLinkCommand2FFEAck[i] = FALSE; } } @@ -401,7 +401,7 @@ void CloseLink(void) gReceivedRemoteLinkPlayers = FALSE; if (gWirelessCommType) { - sub_80F8DC0(); + LinkRfu_Shutdown(); } gLinkOpen = FALSE; DisableSerial(); @@ -468,7 +468,7 @@ void LinkTestProcessKeyInput(void) } if (JOY_NEW(SELECT_BUTTON)) { - sub_800AAC0(); + Link_TryStartSend5FFF(); } if (gLinkTestDebugValuesEnabled) { @@ -613,7 +613,7 @@ void ProcessRecvCmds(u8 unused) linkPlayer->name[9] = 0; linkPlayer->name[8] = 0; } - sub_800B284(linkPlayer); + IntlConvertLinkPlayerName(linkPlayer); if (strcmp(block->magic1, sASCIIGameFreakInc) != 0 || strcmp(block->magic2, sASCIIGameFreakInc) != 0) { @@ -632,10 +632,10 @@ void ProcessRecvCmds(u8 unused) } break; case LINKCMD_0x5FFF: - gUnknown_3003F30[i] = TRUE; + gLinkCommand5FFFAck[i] = TRUE; break; case LINKCMD_0x2FFE: - gUnknown_3003F2C[i] = TRUE; + gLinkCommand2FFEAck[i] = TRUE; break; case LINKCMD_0xAAAA: sub_800A3CC(); @@ -701,7 +701,7 @@ void BuildSendCmd(u16 command) break; case LINKCMD_0x5FFF: gSendCmd[0] = LINKCMD_0x5FFF; - gSendCmd[1] = gUnknown_3003F34; + gSendCmd[1] = gLinkCmd5FFFparam; break; case LINKCMD_0x5566: gSendCmd[0] = LINKCMD_0x5566; @@ -721,7 +721,7 @@ void sub_8009FE8(void) { if (gWirelessCommType) { - sub_80F9828(); + StartSendingKeysToRfu(); } gLinkCallback = sub_800A040; } @@ -1312,54 +1312,54 @@ u8 sub_800AA74(void) return gUnknown_3000E50; } -void sub_800AA80(u16 a0) +void Link_StartSend5FFFwithParam(u16 a0) { if (gWirelessCommType == 1) { - task_add_05_task_del_08FA224_when_no_RfuFunc(); + Rfu_BeginBuildAndSendCommand5F(); } else { if (gLinkCallback == NULL) { - gLinkCallback = sub_800AB0C; - gUnknown_3003F24 = FALSE; - gUnknown_3003F34 = a0; + gLinkCallback = LinkCB_BuildCommand5FFF; + gLinkAllAcked5FFF = FALSE; + gLinkCmd5FFFparam = a0; } } } -void sub_800AAC0(void) +void Link_TryStartSend5FFF(void) { if (gWirelessCommType == 1) { - task_add_05_task_del_08FA224_when_no_RfuFunc(); + Rfu_BeginBuildAndSendCommand5F(); } else { if (gLinkCallback != NULL) { - gUnknown_202285C++; + sStartSend5FFFfailures++; } else { - gLinkCallback = sub_800AB0C; - gUnknown_3003F24 = FALSE; - gUnknown_3003F34 = 0; + gLinkCallback = LinkCB_BuildCommand5FFF; + gLinkAllAcked5FFF = FALSE; + gLinkCmd5FFFparam = 0; } } } -static void sub_800AB0C(void) +static void LinkCB_BuildCommand5FFF(void) { if (gLastRecvQueueCount == 0) { BuildSendCmd(LINKCMD_0x5FFF); - gLinkCallback = sub_800AB38; + gLinkCallback = LinkCB_WaitAckCommand5FFF; } } -static void sub_800AB38(void) +static void LinkCB_WaitAckCommand5FFF(void) { int i; unsigned count; @@ -1369,7 +1369,7 @@ static void sub_800AB38(void) count = 0; for (i = 0; i < linkPlayerCount; i++) { - if (gUnknown_3003F30[i]) + if (gLinkCommand5FFFAck[i]) { count++; } @@ -1380,36 +1380,36 @@ static void sub_800AB38(void) gLinkVSyncDisabled = TRUE; CloseLink(); gLinkCallback = NULL; - gUnknown_3003F24 = TRUE; + gLinkAllAcked5FFF = TRUE; } } -void sub_800AB9C(void) +void PrepareSendLinkCmd2FFE_or_RfuCmd6600(void) { if (gWirelessCommType == 1) { - sub_80FA42C(); + LinkRfu_SetRfuFuncToSend6600(); } else { if (gLinkCallback == NULL) { - gLinkCallback = sub_800ABD4; + gLinkCallback = LinkFunc_Send2FFE_1; } - gUnknown_3003F24 = FALSE; + gLinkAllAcked5FFF = FALSE; } } -static void sub_800ABD4(void) +static void LinkFunc_Send2FFE_1(void) { if (gLastRecvQueueCount == 0) { BuildSendCmd(LINKCMD_0x2FFE); - gLinkCallback = sub_800AC00; + gLinkCallback = LinkFunc_Send2FFE_2; } } -static void sub_800AC00(void) +static void LinkFunc_Send2FFE_2(void) { u8 i; u8 linkPlayerCount; @@ -1417,7 +1417,7 @@ static void sub_800AC00(void) linkPlayerCount = GetLinkPlayerCount(); for (i = 0; i < linkPlayerCount; i++) { - if (!gUnknown_3003F2C[i]) + if (!gLinkCommand2FFEAck[i]) { break; } @@ -1426,7 +1426,7 @@ static void sub_800AC00(void) { for (i = 0; i < MAX_LINK_PLAYERS; i++) { - gUnknown_3003F2C[i] = FALSE; + gLinkCommand2FFEAck[i] = FALSE; } gLinkCallback = NULL; } @@ -1448,7 +1448,7 @@ static void CheckErrorStatus(void) } } -void sub_800ACBC(u32 status, u8 lastSendQueueCount, u8 lastRecvQueueCount, u8 unk_06) +void SetLinkErrorFromRfu(u32 status, u8 lastSendQueueCount, u8 lastRecvQueueCount, u8 unk_06) { sLinkErrorBuffer.status = status; sLinkErrorBuffer.lastSendQueueCount = lastSendQueueCount; @@ -1477,12 +1477,12 @@ void CB2_LinkError(void) { gWirelessCommType = 3; } - sub_80F85F8(); + ResetLinkRfuGFLayer(); } SetVBlankCallback(sub_800978C); - ResetBgsAndClearDma3BusyFlags(0); + ResetBgsAndClearDma3BusyFlags(FALSE); InitBgsFromTemplates(0, sLinkErrorBgTemplates, 2); - gUnknown_2022860 = tilemapBuffer = malloc(0x800); + sLinkErrorBgTilemapBuffer = tilemapBuffer = malloc(0x800); SetBgTilemapBuffer(1, tilemapBuffer); if (InitWindows(sLinkErrorWindowTemplates)) { @@ -1603,12 +1603,12 @@ static void CB2_PrintErrorMessage(void) bool8 GetSioMultiSI(void) { - return (REG_SIOCNT & 0x04) != 0; + return (REG_SIOCNT & SIO_MULTI_SI) != 0; } static bool8 IsSioMultiMaster(void) { - return (REG_SIOCNT & 0x8) && !(REG_SIOCNT & 0x04); + return (REG_SIOCNT & SIO_MULTI_SD) && !(REG_SIOCNT & SIO_MULTI_SI); } bool8 IsLinkConnectionEstablished(void) @@ -1626,7 +1626,7 @@ bool8 HasLinkErrorOccurred(void) return gLinkErrorOccurred; } -void sub_800B0B4(void) +void PrepareLocalLinkPlayerBlock(void) { struct LinkPlayerBlock * block; @@ -1638,7 +1638,7 @@ void sub_800B0B4(void) memcpy(gBlockSendBuffer, block, sizeof(*block)); } -void sub_800B110(u32 who) +void LinkPlayerFromBlock(u32 who) { u8 who_ = who; struct LinkPlayerBlock * block; @@ -1647,7 +1647,7 @@ void sub_800B110(u32 who) block = (struct LinkPlayerBlock *)gBlockRecvBuffer[who_]; player = &gLinkPlayers[who_]; *player = block->linkPlayer; - sub_800B284(player); + IntlConvertLinkPlayerName(player); if (strcmp(block->magic1, sASCIIGameFreakInc) != 0 || strcmp(block->magic2, sASCIIGameFreakInc) != 0) { SetMainCallback2(CB2_LinkError); @@ -1670,8 +1670,8 @@ bool8 HandleLinkConnection(void) } else { - r4 = sub_80FAE94(); - r5 = sub_80FAEF0(); + r4 = LinkRfuMain1(); + r5 = LinkRfuMain2(); if (sub_8058318() == TRUE) { if (r4 == TRUE || IsRfuRecvQueueEmpty() || r5) @@ -1683,7 +1683,7 @@ bool8 HandleLinkConnection(void) return FALSE; } -void sub_800B1F4(void) +void SetWirelessCommType1(void) { if (gReceivedRemoteLinkPlayers == 0) { @@ -1691,7 +1691,7 @@ void sub_800B1F4(void) } } -static void sub_800B210(void) +static void SetWirelessCommType0(void) { if (gReceivedRemoteLinkPlayers == 0) { @@ -1699,7 +1699,7 @@ static void sub_800B210(void) } } -void sub_800B22C(void) +void SetWirelessCommType0_UnusedCopy(void) { if (gReceivedRemoteLinkPlayers == 0) { @@ -1725,7 +1725,7 @@ bool32 sub_800B270(void) return FALSE; } -void sub_800B284(struct LinkPlayer * player) +void IntlConvertLinkPlayerName(struct LinkPlayer * player) { player->name[10] = player->name[8]; ConvertInternationalString(player->name, player->language); diff --git a/src/link_rfu.c b/src/link_rfu.c deleted file mode 100644 index 8ab76ffd5..000000000 --- a/src/link_rfu.c +++ /dev/null @@ -1,1381 +0,0 @@ -#include "global.h" -#include "librfu.h" -#include "link_rfu.h" - -struct UnkRfuStruct_1 gUnknown_3005E10; - -static void sub_80FD4E4(void); -static void sub_80FDC28(u32 a0); -static void sub_80FDC98(u16 reqCommandId, u16 reqResult); -static void sub_80FE394(u16 reqCommandId); -static void sub_80FE418(void); -static void sub_80FE63C(void); -static void sub_80FE6F0(void); -static void sub_80FE74C(void); -static u8 sub_80FE778(void); -static void sub_80FE7F0(u8 a0, u8 a1); -static void sub_80FE818(u8 bmDisconnectSlot); -static void sub_80FE83C(u8 a0); -static void sub_80FE918(void); -static void sub_80FEAF4(void); - -u32 sub_80FD3A4(void) -{ - u32 id = rfu_REQBN_softReset_and_checkID(); - if (id == RFU_ID) - gUnknown_3005E10.unk_08 = 1; - if (gUnknown_3005E10.unk_04 != 0x17 && gUnknown_3005E10.unk_04 != 0x01) - { - gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_04 = 0; - } - gUnknown_3005E10.unk_07 = 0; - gUnknown_3005E10.unk_0d = 0; - gUnknown_3005E10.unk_01 = 0; - gUnknown_3005E10.unk_00 = 0; - gUnknown_3005E10.unk_06 = -1; - sub_80FEAF4(); - return id; -} - -void LinkRfu_REQ_SendData_HandleParentRelationship(u8 clockChangeFlag) -{ - if (gRfuLinkStatus->parentChild == MODE_CHILD) - { - if (gUnknown_3005E10.unk_02 == TRUE) - clockChangeFlag = TRUE; - else - clockChangeFlag = FALSE; - } - else - gUnknown_3005E10.unk_03 = 0; - rfu_REQ_sendData(clockChangeFlag); -} - -s32 sub_80FD430(void (*func1)(u8, u8), void (*func2)(u16)) -{ - if (func1 == NULL) - { - return 4; - } - CpuFill16(0, &gUnknown_3005E10, sizeof(struct UnkRfuStruct_1)); - gUnknown_3005E10.unk_06 = -1; - gUnknown_3005E10.unk_40 = func1; - gUnknown_3005E10.unk_44 = func2; - rfu_setMSCCallback(sub_80FE394); - rfu_setREQCallback(sub_80FDC98); - return 0; -} - -static void sub_80FD484(void) -{ - CpuFill16(0, &gUnknown_3005E10, offsetof(struct UnkRfuStruct_1, unk_40)); - gUnknown_3005E10.unk_06 = -1; -} - -void sub_80FD4B0(const struct UnkLinkRfuStruct_02022B2C *unk0) -{ - sub_80FD4E4(); - gUnknown_3005E10.unk_04 = 1; - gUnknown_3005E10.unk_05 = 2; - gUnknown_3005E10.unk_3c = unk0; - gUnknown_3005E10.unk_09 = unk0->unk_11; - gUnknown_3005E10.unk_32 = unk0->unk_12; - gUnknown_3005E10.unk_18 = unk0->unk_14; - if (unk0->unk_10) - { - gUnknown_3005E10.unk_0b = 1; - } -} - -static void sub_80FD4E4(void) -{ - u8 i; - - gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_04 = 0; - gUnknown_3005E10.unk_06 = -1; - gUnknown_3005E10.unk_07 = 0; - gUnknown_3005E10.unk_10 = 0; - gUnknown_3005E10.unk_0c = 0; - gUnknown_3005E10.unk_24 = 0; - gUnknown_3005E10.unk_30 = 0; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - gUnknown_3005E10.unk_28[i] = 0; - gUnknown_3005E10.unk_34[i] = 0; - } -} - -void sub_80FD52C(void) -{ - gUnknown_3005E10.unk_04 = 0x15; -} - -u8 sub_80FD538(u8 r5, u16 r7, u16 r8, const u16 *r6) -{ - u8 i; - const u16 *buffer; - - if (gUnknown_3005E10.unk_04 != 0 && (gUnknown_3005E10.unk_04 != 0x08 || r5 != 1)) - { - gUnknown_3005E10.unk_14 = 1; - sub_80FE7F0(0xf3, 0x01); - return 1; - } - if (rfu_getMasterSlave() == AGB_CLK_SLAVE) - { - gUnknown_3005E10.unk_14 = 2; - sub_80FE7F0(0xf3, 0x01); - return 2; - } - for (i = 0, buffer = r6; i < 16; i++) - { - if (*buffer++ == 0xFFFF) - { - break; - } - } - if (i == 16) - { - gUnknown_3005E10.unk_14 = 4; - sub_80FE7F0(0xf3, 0x01); - return 4; - } - if (r5 > 1) - { - gUnknown_3005E10.unk_07 = 1; - r5 = 1; - r7 = 0; - } - else - { - gUnknown_3005E10.unk_07 = 0; - } - if (r5 != 0) - { - gUnknown_3005E10.unk_04 = 5; - } - else - { - gUnknown_3005E10.unk_04 = 9; - if (gUnknown_3005E10.unk_0b) - { - gUnknown_3005E10.unk_0b = 2; - } - } - gUnknown_3005E10.unk_06 = r5; - gUnknown_3005E10.unk_1a = r7; - gUnknown_3005E10.unk_26 = r8; - gUnknown_3005E10.unk_20 = r6; - return 0; -} - -u8 sub_80FD610(u16 parentId, u16 unk_1a) -{ - u8 i; - - if (gUnknown_3005E10.unk_04 != 0 && (gUnknown_3005E10.unk_04 < 9 || gUnknown_3005E10.unk_04 > 11)) - { - gUnknown_3005E10.unk_14 = 1; - sub_80FE7F0(0xF3, 0x01); - return 1; - } - if (rfu_getMasterSlave() == AGB_CLK_SLAVE) - { - gUnknown_3005E10.unk_14 = 2; - sub_80FE7F0(0xF3, 0x01); - return 2; - } - for (i = 0; i < gRfuLinkStatus->findParentCount; i++) - { - if (gRfuLinkStatus->partner[i].id == parentId) - { - break; - } - } - if (gRfuLinkStatus->findParentCount == 0 || i == gRfuLinkStatus->findParentCount) - { - gUnknown_3005E10.unk_14 = 3; - sub_80FE7F0(0xF3, 0x01); - return 3; - } - if (gUnknown_3005E10.unk_04 == 0 || gUnknown_3005E10.unk_04 == 9) - { - gUnknown_3005E10.unk_04 = 12; - gUnknown_3005E10.unk_05 = 13; - } - else - { - gUnknown_3005E10.unk_04 = 11; - gUnknown_3005E10.unk_05 = 12; - } - gUnknown_3005E10.unk_1e = parentId; - gUnknown_3005E10.unk_1a = unk_1a; - if (gUnknown_3005E10.unk_07 != 0) - { - gUnknown_3005E10.unk_07 = 7; - } - return 0; -} - -static void sub_80FD6F4(u8 lossSlot) -{ - u8 i; - - if (lossSlot & gUnknown_3005E10.unk_30) - { - gUnknown_3005E10.unk_30 &= ~lossSlot; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((lossSlot >> i) & 1) - { - gUnknown_3005E10.unk_34[i] = 0; - } - } - i = gRfuLinkStatus->linkLossSlotFlag & lossSlot; - if (i) - { - sub_80FE818(i); - } - gUnknown_3005E10.unk_14 = i; - sub_80FE7F0(0x33, i); - } -} - -void sub_80FD760(bool8 a0) -{ - u8 r2; - - r2 = 0; - gUnknown_3005E10.unk_07 = 0; - if (a0) - { - sub_80FD4E4(); - gUnknown_3005E10.unk_04 = 23; - } - else - { - switch (gUnknown_3005E10.unk_04) - { - case 5: - gUnknown_3005E10.unk_04 = 8; - gUnknown_3005E10.unk_05 = 0; - r2 = 0x13; - break; - case 6: - gUnknown_3005E10.unk_04 = 7; - gUnknown_3005E10.unk_05 = 8; - break; - case 7: - gUnknown_3005E10.unk_04 = 7; - gUnknown_3005E10.unk_05 = 8; - break; - case 8: - break; - case 9: - gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_04 = 0; - r2 = 0x21; - break; - case 10: - gUnknown_3005E10.unk_04 = 11; - gUnknown_3005E10.unk_05 = 0; - break; - case 11: - gUnknown_3005E10.unk_04 = 11; - gUnknown_3005E10.unk_05 = 0; - break; - case 12: - gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_04 = 0; - r2 = 0x23; - break; - case 13: - gUnknown_3005E10.unk_04 = 14; - break; - case 14: - gUnknown_3005E10.unk_04 = 14; - break; - case 15: - break; - case 16: - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_11; - gUnknown_3005E10.unk_05 = gUnknown_3005E10.unk_12; - sub_80FE818(gRfuLinkStatus->linkLossSlotFlag); - gUnknown_3005E10.unk_14 = gRfuLinkStatus->linkLossSlotFlag; - sub_80FE7F0(0x33, 0x01); - return; - case 17: - gUnknown_3005E10.unk_04 = 18; - break; - case 18: - gUnknown_3005E10.unk_04 = 18; - break; - default: - gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_04 = 0; - r2 = 0x43; - break; - } - if (gUnknown_3005E10.unk_04 == 0) - { - sub_80FE7F0(r2, 0); - } - } -} - -static bool8 sub_80FD850(u16 reqCommandId) -{ - bool8 retVal; - u8 i; - u8 bmLinkLossSlot; - u8 linkLossReason; - u8 parentBmLinkRecoverySlot; - u8 flags; - - retVal = FALSE; - rfu_REQBN_watchLink(reqCommandId, &bmLinkLossSlot, &linkLossReason, &parentBmLinkRecoverySlot); - if (bmLinkLossSlot) - { - gUnknown_3005E10.unk_14 = bmLinkLossSlot; - gUnknown_3005E10.unk_16 = linkLossReason; - if (gUnknown_3005E10.unk_09) - { - gUnknown_3005E10.unk_0a = 1; - if (gUnknown_3005E10.unk_06 == 0 && linkLossReason == REASON_DISCONNECTED) - { - gUnknown_3005E10.unk_0a = 4; - } - if (gUnknown_3005E10.unk_0a == 1) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((bmLinkLossSlot >> i) & 1) - { - gUnknown_3005E10.unk_30 |= (1 << i); - gUnknown_3005E10.unk_34[i] = gUnknown_3005E10.unk_32; - } - } - sub_80FE7F0(0x31, 0x01); - } - else - { - gUnknown_3005E10.unk_0a = 0; - sub_80FE818(bmLinkLossSlot); - retVal = TRUE; - sub_80FE7F0(0x33, 0x01); - } - } - else - { - sub_80FE818(bmLinkLossSlot); - retVal = TRUE; - sub_80FE7F0(0x30, 0x02); - } - sub_80FEAF4(); - } - if (gRfuLinkStatus->parentChild == MODE_PARENT) - { - if (parentBmLinkRecoverySlot) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((gUnknown_3005E10.unk_30 >> i) & 1 && (parentBmLinkRecoverySlot >> i) & 1) - { - gUnknown_3005E10.unk_34[i] = 0; - } - } - gUnknown_3005E10.unk_30 &= ~parentBmLinkRecoverySlot; - gUnknown_3005E10.unk_14 = parentBmLinkRecoverySlot; - sub_80FE7F0(0x32, 0x01); - } - if (gUnknown_3005E10.unk_30) - { - flags = 0; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((gUnknown_3005E10.unk_30 >> i) & 1 && gUnknown_3005E10.unk_34[i] && --gUnknown_3005E10.unk_34[i] == 0) - { - gUnknown_3005E10.unk_30 &= ~(1 << i); - flags |= (1 << i); - } - } - if (flags) - { - sub_80FE818(flags); - retVal = TRUE; - gUnknown_3005E10.unk_14 = flags; - sub_80FE7F0(0x33, 0x01); - } - } - if (!gUnknown_3005E10.unk_30) - { - gUnknown_3005E10.unk_0a = 0; - } - } - return retVal; -} - -void LinkRfu_syncVBlank_(void) -{ - if (rfu_syncVBlank()) - { - sub_80FE7F0(0xF1, 0x00); - sub_80FEAF4(); - } -} - -void sub_80FDA30(u32 a0) -{ - u8 r2; - - if (gUnknown_3005E10.unk_40 == NULL && gUnknown_3005E10.unk_04 != 0) - { - gUnknown_3005E10.unk_04 = 0; - } - else - { - if (gUnknown_3005E10.unk_07 != 0) - { - sub_80FDC28(a0); - } - do - { - if (gUnknown_3005E10.unk_04 != 0) - { - rfu_waitREQComplete(); - gUnknown_3005E10.unk_0e = 1; - switch (gUnknown_3005E10.unk_04) - { - case 23: - r2 = sub_80FD3A4() == RFU_ID ? 0x44 : 0xFF; - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE7F0(r2, 0); - break; - case 1: - if (sub_80FD3A4() == RFU_ID) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_05 = 3; - } - else - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE7F0(0xFF, 0); - } - break; - case 2: - rfu_REQ_reset(); - break; - case 3: - rfu_REQ_configSystem(gUnknown_3005E10.unk_3c->availSlotFlag, gUnknown_3005E10.unk_3c->maxMFrame, gUnknown_3005E10.unk_3c->mcTimer); - break; - case 4: - rfu_REQ_configGameData(gUnknown_3005E10.unk_3c->mbootFlag, gUnknown_3005E10.unk_3c->serialNo, (const u8 *)gUnknown_3005E10.unk_3c->gname, gUnknown_3005E10.unk_3c->uname); - break; - case 5: - rfu_REQ_startSearchChild(); - break; - case 6: - rfu_REQ_pollSearchChild(); - break; - case 7: - rfu_REQ_endSearchChild(); - break; - case 8: - break; - case 9: - rfu_REQ_startSearchParent(); - break; - case 10: - rfu_REQ_pollSearchParent(); - break; - case 11: - rfu_REQ_endSearchParent(); - break; - case 12: - rfu_REQ_startConnectParent(gUnknown_3005E10.unk_1e); - break; - case 13: - rfu_REQ_pollConnectParent(); - break; - case 14: - rfu_REQ_endConnectParent(); - break; - case 15: - break; - case 16: - rfu_REQ_CHILD_startConnectRecovery(gRfuLinkStatus->linkLossSlotFlag); - break; - case 17: - rfu_REQ_CHILD_pollConnectRecovery(); - break; - case 18: - rfu_REQ_CHILD_endConnectRecovery(); - break; - case 19: - rfu_REQ_changeMasterSlave(); - break; - case 20: - break; - case 21: - rfu_REQ_stopMode(); - break; - case 22: - break; - } - rfu_waitREQComplete(); - gUnknown_3005E10.unk_0e = 0; - } - } while (gUnknown_3005E10.unk_04 == 18 || gUnknown_3005E10.unk_04 == 19); - if (gRfuLinkStatus->parentChild != MODE_PARENT || !sub_80FD850(0)) - { - sub_80FE418(); - sub_80FE63C(); - sub_80FE74C(); - sub_80FE918(); - } - } -} - -static void sub_80FDC28(u32 a0) -{ - if (gUnknown_3005E10.unk_07 == 5) - { - gUnknown_3005E10.unk_06 = 1; - gUnknown_3005E10.unk_04 = 5; - gUnknown_3005E10.unk_1a = gUnknown_3005E10.unk_1c; - if (gUnknown_3005E10.unk_1a) - { - gUnknown_3005E10.unk_07 = 6; - } - else - { - gUnknown_3005E10.unk_07 = 1; - } - } - if (gUnknown_3005E10.unk_07 == 1) - { - gUnknown_3005E10.unk_06 = 1; - gUnknown_3005E10.unk_04 = 5; - gUnknown_3005E10.unk_1a = a0 % 140; - gUnknown_3005E10.unk_1c = 140 - gUnknown_3005E10.unk_1a; - if (gUnknown_3005E10.unk_1a) - { - gUnknown_3005E10.unk_07 = 2; - } - else - { - gUnknown_3005E10.unk_07 = 3; - } - } - if (gUnknown_3005E10.unk_07 == 3) - { - gUnknown_3005E10.unk_06 = 0; - gUnknown_3005E10.unk_1a = 40; - gUnknown_3005E10.unk_07 = 4; - gUnknown_3005E10.unk_04 = 9; - } -} - -static void sub_80FDC98(u16 reqCommandId, u16 reqResult) -{ - u8 sp0; - register u8 *stwiRecvBuffer asm("r0"); - u8 *tmp; - u8 i; - - if (gUnknown_3005E10.unk_0e != 0) - { - gUnknown_3005E10.unk_0e = 0; - switch (reqCommandId) - { - case ID_RESET_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_05 = 4; - } - break; - case ID_SYSTEM_CONFIG_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_05 = 0; - } - break; - case ID_GAME_CONFIG_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE7F0(0x00, 0x00); - } - break; - case ID_SC_START_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 6; - } - break; - case ID_SC_POLL_REQ: - if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0) - { - gUnknown_3005E10.unk_04 = 7; - gUnknown_3005E10.unk_05 = 8; - } - break; - case ID_SC_END_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_05 = 0; - if (gUnknown_3005E10.unk_07 == 0) - { - sub_80FE7F0(0x13, 0x00); - } - } - break; - case ID_SP_START_REQ: - if (reqResult == 0) - { - if (gUnknown_3005E10.unk_0b == 1 && gUnknown_3005E10.unk_1a > 1) - { - gUnknown_3005E10.unk_1a--; - } - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 10; - } - break; - case ID_SP_POLL_REQ: - if (reqResult == 0) - { - sp0 = sub_80FE778(); - gUnknown_3005E10.unk_14 = sp0; - if (sp0) - { - sub_80FE7F0(0x20, 0x01); - } - if (gUnknown_3005E10.unk_0b && gUnknown_3005E10.unk_1a != 1 && gRfuLinkStatus->findParentCount == RFU_CHILD_MAX) - { - rfu_REQ_endSearchParent(); - rfu_waitREQComplete(); - gUnknown_3005E10.unk_04 = 9; - gUnknown_3005E10.unk_0b = 1; - } - } - if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0) - { - gUnknown_3005E10.unk_04 = 11; - gUnknown_3005E10.unk_05 = 0; - } - break; - case ID_SP_END_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - if (gUnknown_3005E10.unk_07 == 0) - { - if (gUnknown_3005E10.unk_04 == 0) - { - sub_80FE7F0(0x21, 0x00); - } - } - else if (gUnknown_3005E10.unk_07 != 7) - { - gUnknown_3005E10.unk_04 = 5; - gUnknown_3005E10.unk_07 = 5; - } - } - break; - case ID_CP_START_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 13; - } - break; - case ID_CP_POLL_REQ: - if (reqResult == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_3005E10.unk_10) && !sp0) - { - gUnknown_3005E10.unk_04 = 14; - } - if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0) - { - gUnknown_3005E10.unk_04 = 14; - } - break; - case ID_CP_END_REQ: - if (reqResult == 0 && !rfu_getConnectParentStatus(&sp0, &gUnknown_3005E10.unk_10)) - { - if (!sp0) - { - gUnknown_3005E10.unk_04 = 19; - gUnknown_3005E10.unk_05 = 15; - gUnknown_3005E10.unk_1e = 0x22; - gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_10; - } - else - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - gUnknown_3005E10.unk_1e = 0x23; - gUnknown_3005E10.unk_14 = sp0; - if (gUnknown_3005E10.unk_07) - { - gUnknown_3005E10.unk_07 = 3; - gUnknown_3005E10.unk_04 = 9; - } - } - sub_80FE7F0(gUnknown_3005E10.unk_1e, 0x01); - gUnknown_3005E10.unk_1e = 0; - } - break; - case ID_CPR_START_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_14 = gRfuLinkStatus->linkLossSlotFlag; - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 17; - for (gUnknown_3005E10.unk_10 = 0; gUnknown_3005E10.unk_10 < RFU_CHILD_MAX; gUnknown_3005E10.unk_10++) - { - if ((gRfuLinkStatus->linkLossSlotFlag >> gUnknown_3005E10.unk_10) & 1) - { - break; - } - } - } - break; - case ID_CPR_POLL_REQ: - if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0) && sp0 < 2) - { - gUnknown_3005E10.unk_04 = 18; - } - if (gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] && --gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] == 0) - { - gUnknown_3005E10.unk_04 = 18; - } - break; - case ID_CPR_END_REQ: - if (reqResult == 0 && !rfu_CHILD_getConnectRecoveryStatus(&sp0)) - { - if (!sp0) - { - gUnknown_3005E10.unk_04 = 19; - gUnknown_3005E10.unk_05 = 22; - gUnknown_3005E10.unk_1e = 0x32; - } - else - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE818(gRfuLinkStatus->linkLossSlotFlag); - gUnknown_3005E10.unk_1e = 0x33; - } - gUnknown_3005E10.unk_34[gUnknown_3005E10.unk_10] = 0; - gUnknown_3005E10.unk_30 = 0; - gUnknown_3005E10.unk_0a = 0; - sub_80FE7F0(gUnknown_3005E10.unk_1e, 0x01); - gUnknown_3005E10.unk_1e = 0; - } - break; - case ID_MS_CHANGE_REQ: - if (reqResult == 0) - { - if (gUnknown_3005E10.unk_05 == 22) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_11; - gUnknown_3005E10.unk_05 = gUnknown_3005E10.unk_12; - gUnknown_3005E10.unk_02 = 1; - sub_80FE7F0(0x41, 0x00); - } - else if (gUnknown_3005E10.unk_05 == 15) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_02 = 1; - sub_80FE7F0(0x41, 0x00); - gUnknown_3005E10.unk_24 |= 1 << gUnknown_3005E10.unk_10; - gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = gUnknown_3005E10.unk_26; - rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10); - tmp = &sp0; - *tmp = rfu_NI_CHILD_setSendGameName(gUnknown_3005E10.unk_10, 0x0e); - if (*tmp) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FEAF4(); - sub_80FE818(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); - gUnknown_3005E10.unk_14 = sp0; - sub_80FE7F0(0x25, 0x01); - } - } - } - break; - case ID_STOP_MODE_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE7F0(0x42, 0x00); - } - break; - } - gUnknown_3005E10.unk_0e = 1; - } - else if (reqResult == 3 && gUnknown_3005E10.unk_0f && (reqCommandId == ID_DATA_TX_REQ || reqCommandId == ID_DATA_RX_REQ || reqCommandId == ID_MS_CHANGE_REQ)) - { - rfu_REQ_RFUStatus(); - rfu_waitREQComplete(); - rfu_getRFUStatus(&sp0); - if (sp0 == 0 && gRfuLinkStatus->parentChild == MODE_CHILD) - { - stwiRecvBuffer = rfu_getSTWIRecvBuffer()->rxPacketAlloc.rfuPacket8.data; - stwiRecvBuffer[4] = gRfuLinkStatus->connSlotFlag; - stwiRecvBuffer[5] = 1; - sub_80FD850(0x29); - reqResult = 0; - } - } - switch (reqCommandId) - { - case ID_DISCONNECT_REQ: - if (reqResult == 0) - { - stwiRecvBuffer = rfu_getSTWIRecvBuffer()->rxPacketAlloc.rfuPacket8.data; - gUnknown_3005E10.unk_14 = stwiRecvBuffer[8]; - sub_80FE83C(gUnknown_3005E10.unk_14); - if (gUnknown_3005E10.unk_30) - { - gUnknown_3005E10.unk_30 &= ~gUnknown_3005E10.unk_14; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((gUnknown_3005E10.unk_14 >> i) & 1) - { - gUnknown_3005E10.unk_34[i] = 0; - } - } - if (gUnknown_3005E10.unk_06 == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - } - } - sp0 = gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if ((sp0 >> i) & 1 && gUnknown_3005E10.unk_01) - { - gUnknown_3005E10.unk_01--; - } - } - gUnknown_3005E10.unk_00 &= ~gUnknown_3005E10.unk_14; - if (gUnknown_3005E10.unk_07) - { - if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) - { - if (gUnknown_3005E10.unk_07 == 8) - { - gUnknown_3005E10.unk_1a = gUnknown_3005E10.unk_1c; - gUnknown_3005E10.unk_07 = 6; - gUnknown_3005E10.unk_04 = 6; - } - else if (gUnknown_3005E10.unk_04 != 6 && gUnknown_3005E10.unk_04 != 7) - { - gUnknown_3005E10.unk_07 = 1; - gUnknown_3005E10.unk_04 = 5; - } - } - } - if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) - { - if (gUnknown_3005E10.unk_04 == 0) - { - gUnknown_3005E10.unk_06 = -1; - } - } - if (gUnknown_3005E10.unk_0e == 0) - { - sub_80FE7F0(0x40, 0x01); - } - } - break; - case ID_DATA_RX_REQ: - sub_80FE6F0(); - if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) - { - sub_80FE7F0(0x50, 0x00); - } - break; - case ID_RESET_REQ: - case ID_STOP_MODE_REQ: - if (reqResult == 0) - { - gUnknown_3005E10.unk_0d = 0; - gUnknown_3005E10.unk_01 = 0; - gUnknown_3005E10.unk_00 = 0;; - gUnknown_3005E10.unk_06 = -1; - sub_80FEAF4(); - if (reqCommandId == 61) - { - sub_80FD484(); - } - } - break; - } - if (reqResult != 0) - { - if (reqCommandId == ID_SP_START_REQ && reqResult != 0 && gUnknown_3005E10.unk_07 == 4) - { - gRfuLinkStatus->parentChild = MODE_PARENT; - gRfuLinkStatus->connSlotFlag = 0xF; - sub_80FE818(15); - rfu_waitREQComplete(); - return; - } - else - { - gUnknown_3005E10.unk_14 = reqCommandId; - gUnknown_3005E10.unk_16 = reqResult; - if (gUnknown_3005E10.unk_0e) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - } - sub_80FE7F0(0xf0, 0x02); - sub_80FEAF4(); - } - } - if (reqCommandId == ID_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA_REQ) - { - sub_80FE7F0(0xf2, 0x00); - sub_80FEAF4(); - } -} - -static void sub_80FE394(u16 reqCommandId) -{ - u8 r7; - u8 ackFlag; - - r7 = gUnknown_3005E10.unk_0e; - gUnknown_3005E10.unk_0e = 0; - gUnknown_3005E10.unk_0f = 1; - if (gRfuLinkStatus->parentChild == MODE_CHILD) - { - sub_80FD850(reqCommandId); - if (gUnknown_3005E10.unk_02 != 1) - { - sub_80FEAF4(); - gUnknown_3005E10.unk_0f = 0; - gUnknown_3005E10.unk_0e = r7; - return; - } - } - else - { - if (!rfu_UNI_PARENT_getDRAC_ACK(&ackFlag)) - { - gUnknown_3005E10.unk_03 |= ackFlag; - } - } - if (gUnknown_3005E10.unk_44 != NULL) - { - gUnknown_3005E10.unk_44(reqCommandId); - rfu_waitREQComplete(); - if (gUnknown_3005E10.unk_02 == 2) - { - sub_80FEAF4(); - } - } - gUnknown_3005E10.unk_0f = 0; - gUnknown_3005E10.unk_0e = r7; -} - -static void sub_80FE418(void) -{ - u8 flags; - u8 sp0; - u8 i; - u8 r5; - u8 r4; - const u16 *ptr; - - if (gUnknown_3005E10.unk_04 == 5 || gUnknown_3005E10.unk_04 == 6 || gUnknown_3005E10.unk_04 == 7 || gUnknown_3005E10.unk_04 == 8) - { - flags = ((gRfuLinkStatus->connSlotFlag ^ gUnknown_3005E10.unk_0c) & gRfuLinkStatus->connSlotFlag) & ~gRfuLinkStatus->getNameFlag; - gUnknown_3005E10.unk_0c = gRfuLinkStatus->connSlotFlag; - if (flags) - { - gUnknown_3005E10.unk_14 = flags; - sub_80FE7F0(0x10, 0x01); - } - sp0 = 0x00; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - r4 = 1 << i; - r5 = 0x00; - if (flags & r4) - { - gUnknown_3005E10.unk_28[i] = gUnknown_3005E10.unk_26; - gUnknown_3005E10.unk_24 |= r4; - } - else if (gUnknown_3005E10.unk_24 & r4) - { - if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS) - { - if (gRfuSlotStatusNI[i]->recv.dataType == 1) // Game identification information - { - r5 = 0x02; - for (ptr = gUnknown_3005E10.unk_20; *ptr != 0xFFFF; ptr++) - { - if (gRfuLinkStatus->partner[i].serialNo == *ptr) - { - gUnknown_3005E10.unk_00 |= r4; - gUnknown_3005E10.unk_01++; - sp0 |= r4; - r5 |= 0x01; - break; - } - } - if (!(r5 & 0x01)) - { - r5 |= 0x04; - } - } - } - else if (--gUnknown_3005E10.unk_28[i] == 0) - { - r5 = 0x06; - } - if (r5 & 0x02) - { - gUnknown_3005E10.unk_24 &= ~r4; - gUnknown_3005E10.unk_28[i] = 0; - rfu_clearSlot(TYPE_NI_RECV, i); - } - if (r5 & 0x04) - { - gUnknown_3005E10.unk_0d |= r4; - } - } - } - if (sp0) - { - gUnknown_3005E10.unk_14 = sp0; - sub_80FE7F0(0x11, 0x01); - } - if (gUnknown_3005E10.unk_0d) - { - r5 = 0x01; - if (gRfuLinkStatus->sendSlotUNIFlag && ((gUnknown_3005E10.unk_03 & gUnknown_3005E10.unk_00) != gUnknown_3005E10.unk_00)) - { - r5 = 0x00; - } - if (r5) - { - sub_80FE818(gUnknown_3005E10.unk_0d); - gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_0d; - gUnknown_3005E10.unk_0d = 0; - sub_80FE7F0(0x12, 0x01); - } - } - if (gUnknown_3005E10.unk_24 == 0 && gUnknown_3005E10.unk_04 == 8) - { - if (gUnknown_3005E10.unk_07 == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE7F0(0x14, 0x00); - } - else - { - if (gUnknown_3005E10.unk_07 == 2) - { - gUnknown_3005E10.unk_07 = 3; - gUnknown_3005E10.unk_04 = 9; - } - else - { - gUnknown_3005E10.unk_07 = 1; - gUnknown_3005E10.unk_04 = 5; - } - if (gUnknown_3005E10.unk_00) - { - gUnknown_3005E10.unk_1a = 0; - gUnknown_3005E10.unk_07 = 8; - gUnknown_3005E10.unk_04 = 5; - } - } - } - } -} - -static void sub_80FE63C(void) -{ - u16 imeBak = REG_IME; - REG_IME = 0; - if (gUnknown_3005E10.unk_04 == 15) - { - if (--gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] == 0 || gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == SLOT_STATE_SEND_FAILED) - { - sub_80FEB14(); - gUnknown_3005E10.unk_04 = 24; - rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10); - gUnknown_3005E10.unk_24 &= ~(1 << gUnknown_3005E10.unk_10); - gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = 0; - } - } - REG_IME = imeBak; - if (gUnknown_3005E10.unk_04 == 24) - { - if (gUnknown_3005E10.unk_02 == 1) - { - sub_80FEB14(); - } - if (gUnknown_3005E10.unk_02 == 0) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - sub_80FE818(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); - gUnknown_3005E10.unk_14 = 0; - sub_80FE7F0(0x25, 0x01); - } - } -} - -static void sub_80FE6F0(void) -{ - if (gUnknown_3005E10.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == SLOT_STATE_SEND_SUCCESS) - { - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; - rfu_clearSlot(TYPE_NI_SEND, gUnknown_3005E10.unk_10); - gUnknown_3005E10.unk_24 &= ~(1 << gUnknown_3005E10.unk_10); - gUnknown_3005E10.unk_28[gUnknown_3005E10.unk_10] = 0; - sub_80FE7F0(0x24, 0x00); - } -} - -static void sub_80FE74C(void) -{ - if (gUnknown_3005E10.unk_06 == 0 && gUnknown_3005E10.unk_0a == 1) - { - gUnknown_3005E10.unk_11 = gUnknown_3005E10.unk_04; - gUnknown_3005E10.unk_12 = gUnknown_3005E10.unk_05; - gUnknown_3005E10.unk_04 = 16; - gUnknown_3005E10.unk_05 = 17; - gUnknown_3005E10.unk_0a = 2; - } -} - -static u8 sub_80FE778(void) -{ - u8 i; - const u16 *ptr; - u8 flags = 0x00; - - for (i = 0; i < gRfuLinkStatus->findParentCount; i++) - { - for (ptr = gUnknown_3005E10.unk_20; *ptr != 0xFFFF; ptr++) - { - if (gRfuLinkStatus->partner[i].serialNo == *ptr) - { - flags |= (1 << i); - } - } - } - return flags; -} - -static void sub_80FE7F0(u8 a0, u8 a1) -{ - if (gUnknown_3005E10.unk_40 != NULL) - { - gUnknown_3005E10.unk_40(a0, a1); - } - gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_16 = 0; -} - -static void sub_80FE818(u8 a0) -{ - u8 unk_0e_bak = gUnknown_3005E10.unk_0e; - gUnknown_3005E10.unk_0e = 1; - rfu_REQ_disconnect(a0); - rfu_waitREQComplete(); - gUnknown_3005E10.unk_0e = unk_0e_bak; -} - -static void sub_80FE83C(u8 a0) -{ - u8 i; - - if (gRfuLinkStatus->sendSlotNIFlag) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->send.bmSlot & a0) - { - rfu_changeSendTarget(TYPE_NI, i, gRfuSlotStatusNI[i]->send.bmSlot & ~a0); - } - } - } - if (gRfuLinkStatus->recvSlotNIFlag) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.bmSlot & a0) - { - rfu_NI_stopReceivingData(i); - } - } - } - if (gRfuLinkStatus->sendSlotUNIFlag) - { - gRfuLinkStatus->sendSlotUNIFlag &= ~a0; - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI && a0 & gRfuSlotStatusUNI[i]->send.bmSlot) - { - gRfuSlotStatusUNI[i]->send.bmSlot &= ~a0; - } - } - } -} - -static void sub_80FE918(void) -{ - u8 i; - u8 j; - u8 flags; - - if (gUnknown_3005E10.unk_18) - { - if (gRfuLinkStatus->sendSlotNIFlag) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG) - { - flags = 0; - for (j = 0; j < RFU_CHILD_MAX; j++) - { - if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > gUnknown_3005E10.unk_18) - { - flags |= (1 << j); - } - if (flags) - { - rfu_changeSendTarget(TYPE_NI, i, flags ^ gRfuSlotStatusNI[i]->send.bmSlot); - } - } - } - } - } - if (gRfuLinkStatus->recvSlotNIFlag) - { - for (i = 0; i < RFU_CHILD_MAX; i++) - { - if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.failCounter > gUnknown_3005E10.unk_18) - { - rfu_NI_stopReceivingData(i); - } - } - } - } -} - -void sub_80FEA10(void (*func)(u16)) -{ - gUnknown_3005E10.unk_44 = func; - rfu_setMSCCallback(sub_80FE394); -} - -static void sub_80FEA28(void (*func)(u8, u8)) -{ - gUnknown_3005E10.unk_40 = func; -} - -u8 sub_80FEA34(u8 a0, u16 a1) -{ - u16 imeBak; - if (gUnknown_3005E10.unk_09 && a0 == 0 && gUnknown_3005E10.unk_30) - { - return 5; - } - imeBak = REG_IME; - REG_IME = 0; - gUnknown_3005E10.unk_09 = a0; - gUnknown_3005E10.unk_32 = a1; - REG_IME = imeBak; - return 0; -} - -static u8 sub_80FEA78(u16 a0) -{ - if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag) - { - gUnknown_3005E10.unk_14 = 6; - sub_80FE7F0(0xf3, 0x01); - return 6; - } - gUnknown_3005E10.unk_18 = a0; - return 0; -} - -static u8 sub_80FEAB4(u8 a0) -{ - if (gUnknown_3005E10.unk_04 == 9 || gUnknown_3005E10.unk_04 == 10 || gUnknown_3005E10.unk_04 == 11) - { - gUnknown_3005E10.unk_14 = 7; - sub_80FE7F0(0xf3, 0x01); - return 7; - } - if (a0) - { - gUnknown_3005E10.unk_0b = 1; - } - else - { - gUnknown_3005E10.unk_0b = 0; - } - return 0; -} - -static void sub_80FEAF4(void) -{ - if (gUnknown_3005E10.unk_02) - { - gUnknown_3005E10.unk_02 = 0; - sub_80FE7F0(0x45, 0x00); - } -} - -void sub_80FEB14(void) -{ - if (gUnknown_3005E10.unk_02 == 0) - { - sub_80FE7F0(0x45, 0x00); - } - else if (gUnknown_3005E10.unk_02 == 1) - { - gUnknown_3005E10.unk_02 = 2; - } -} - -void sub_80FEB3C(void) -{ - if (gUnknown_3005E10.unk_07) - { - switch (gUnknown_3005E10.unk_04) - { - case 5: - gUnknown_3005E10.unk_07 = 3; - gUnknown_3005E10.unk_04 = 9; - break; - case 6: - gUnknown_3005E10.unk_07 = 2; - gUnknown_3005E10.unk_1a = 1; - break; - case 7: - case 8: - gUnknown_3005E10.unk_07 = 2; - break; - case 9: - case 10: - gUnknown_3005E10.unk_1a = 40; - break; - case 11: - gUnknown_3005E10.unk_1a = 40; - gUnknown_3005E10.unk_04 = 10; - break; - } - } -} diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index a27948650..2259e9214 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -12,67 +12,69 @@ #include "string_util.h" #include "task.h" #include "constants/species.h" +#include "constants/union_room.h" -struct UnkRfuStruct_8010A14{ - char unk_00[15]; // PokemonSioInfo - u8 unk_0f; - u8 unk_10[4]; - struct LinkPlayer unk_14[5]; +struct SioInfo +{ + char magic[15]; // PokemonSioInfo + u8 playerCount; + u8 linkPlayerIdx[RFU_CHILD_MAX]; + struct LinkPlayer linkPlayers[MAX_RFU_PLAYERS]; u8 fill_a0[0x5c]; }; -static EWRAM_DATA struct UnkLinkRfuStruct_02022B2C sRfuReqConfig = {}; +static EWRAM_DATA struct InitializeParametersTag sRfuReqConfig = {}; static EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; -static struct RfuAPIBuffer gRfuAPIBuffer; -static u8 gUnknown_3001FF8[14]; -static u16 gUnknown_3002008[7]; +static u32 gf_rfu_REQ_api[RFU_API_BUFF_SIZE_RAM / 4]; +static u8 sResendBlock8[14]; +static u16 sResendBlock16[7]; struct GFtgtGname gHostRFUtgtGnameBuffer; -struct UnkRfuStruct_2 Rfu; +GF_RFU_MANAGER Rfu; u8 gHostRFUtgtUnameBuffer[PLAYER_NAME_LENGTH + 1]; static void sub_80F8AA4(void); static void sub_80F8AEC(void); -static void sub_80F8D20(u16 a0); -static void sub_80F8DA8(u16 a0); +static void MscCallback_Child(u16 a0); +static void MSCCallback_SetUnkCDB(u16 a0); static void sub_80F906C(void); -static void sub_80F9868(u8 unused); -static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data); -static void sub_80F9D04(u16 command); -static void rfufunc_80F9F44(void); -static void sub_80F9FA8(void); -static void rfufunc_80FA020(void); +static void RfuHandleReceiveCommand(u8 unused); +static void ResetSendDataManager(struct RfuBlockSend *data); +static void RfuPrepareSendBuffer(u16 command); +static void RfuFunc_HandleBlockSend(void); +static void RfuFunc_SendNextBlock(void); +static void RfuFunc_SendLastBlock(void); static void CallRfuFunc(void); static void sub_80FA738(void); static int sub_80FA788(void); static void sub_80FA834(u8 taskId); static void sub_80FA9D0(u16 a0); -static void sub_80FAA58(void * a0); -static void sub_80FAA94(u8 taskId); +static void ValidateAndReceivePokemonSioInfo(void * a0); +static void Task_ExchangeLinkPlayers(u8 taskId); static void sub_80FACF0(u8 taskId); -static void sub_80FB0E8(u32 a0); -static void sub_80FB564(s32 a0); +static void GetLinkmanErrorParams(u32 msg); +static void sub_80FB564(s32 bmConnectedFlag); static void sub_80FBB74(void); -static u8 sub_80FBC70(const u8 *a0, u16 a1); -static void sub_80FBCF8(u32 a0); +static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId); +static void RfuReqDisconnectSlot(u32 bmDisconnectSlot); static void sub_80FBE20(u32 a0, u32 a1); static void sub_80FC028(u8 taskId); -static void sub_80FC208(void); -static void nullsub_89(u8 taskId); +static void rfu_dbg_clear(void); +static void Task_idle(u8 taskId); -static const struct UnkLinkRfuStruct_02022B2C sRfuReqConfigTemplate = { +static const struct InitializeParametersTag sRfuReqConfigTemplate = { .maxMFrame = 4, - .mcTimer = 32, - .availSlotFlag = 0, - .mbootFlag = 0, + .MC_TimerCount = 32, + .availSlot_flag = 0, + .mboot_flag = 0, .serialNo = 0x0002, - .gname = &gHostRFUtgtGnameBuffer, - .uname = gHostRFUtgtUnameBuffer, - .unk_10 = 0x01, - .unk_11 = 0x00, - .unk_12 = 0x0258, - .unk_14 = 0x012c + .gameName = (void *)&gHostRFUtgtGnameBuffer, + .userName = gHostRFUtgtUnameBuffer, + .fastSearchParent_flag = TRUE, + .linkRecovery_enable = FALSE, + .linkRecovery_period = 600, + .NI_failCounter_limit = 300 }; static const u8 sAvailSlots[] = { @@ -82,7 +84,7 @@ static const u8 sAvailSlots[] = { [4] = AVAIL_SLOT4 }; -static const u32 gUnknown_843EBD4[] = { +static const u32 sAllBlocksReceived[] = { 0x000000, 0x000001, 0x000003, @@ -138,8 +140,10 @@ static const struct { { gBlockSendBuffer, 40 } }; -static const u16 gUnknown_843EC8C[] = { - 0x0002, 0x7f7d, 0xFFFF +static const u16 sAcceptedSerialNos[] = { + 0x0002, // Pokemon FR/LG/EM + 0x7f7d, + 0xFFFF }; static const char sUnref_843EC92[][15] = { @@ -166,38 +170,38 @@ static const char sUnref_843ED37[][16] = { static const TaskFunc gUnknown_843ED88[] = { sub_80FA834, - sub_80FAA94, + Task_ExchangeLinkPlayers, sub_80FACF0 }; -static void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2) +static void rfu_dbg_print_str(const void *string, u8 x, u8 y) { // debug? } -static void nullsub_88(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3) +static void rfu_dbg_print_num(u16 num, u8 x, u8 y, u8 ndigits) { } -void sub_80F85F8(void) +void ResetLinkRfuGFLayer(void) { s32 i; - u8 unk_ee_bak = Rfu.unk_ee; + u8 errorState_bak = Rfu.errorState; CpuFill16(0, &Rfu, sizeof Rfu); - Rfu.unk_0c = 0xFF; - Rfu.unk_ee = unk_ee_bak; - if (Rfu.unk_ee != 4) + Rfu.parent_child = MODE_NEUTRAL; + Rfu.errorState = errorState_bak; + if (Rfu.errorState != 4) { - Rfu.unk_ee = 0; + Rfu.errorState = 0; } for (i = 0; i < 5; i++) { - sub_80F9CB4(Rfu.unk_80 + i); + ResetSendDataManager(Rfu.cmd_8800_recvbuf + i); } - sub_80F9CB4(&Rfu.unk_6c); - sub_80FC478(&Rfu.unk_124); - sub_80FC4D4(&Rfu.unk_9e8); + ResetSendDataManager(&Rfu.cmd_8800_sendbuf); + RFU_queue_20_70_reset(&Rfu.unk_124); + RFU_queue_40_14_reset(&Rfu.unk_9e8); CpuFill16(0, gSendCmd, sizeof gSendCmd); CpuFill16(0, gRecvCmds, sizeof gRecvCmds); CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers); @@ -218,46 +222,46 @@ void InitRFU(void) void sub_80F86F4(void) { - if (!rfu_initializeAPI(&gRfuAPIBuffer, sizeof gRfuAPIBuffer, gIntrTable + 1, TRUE)) + if (!rfu_initializeAPI(gf_rfu_REQ_api, RFU_API_BUFF_SIZE_RAM, gIntrTable + 1, TRUE)) { gLinkType = 0; sub_80FB128(FALSE); - sub_80F85F8(); + ResetLinkRfuGFLayer(); rfu_setTimerInterrupt(3, gIntrTable + 2); } } -static void sub_80F8738(u8 taskId) +static void Task_LinkLeaderSearchForChildren(u8 taskId) { sub_80FA738(); - switch (Rfu.unk_04) + switch (Rfu.state) { case 0: - sub_80FD4B0(&sRfuReqConfig); - Rfu.unk_04 = 1; + rfu_LMAN_initializeRFU(&sRfuReqConfig); + Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 2: - sub_80FD538(Rfu.unk_0c, 0, 240, gUnknown_843EC8C); - Rfu.unk_04 = 3; + rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos); + Rfu.state = 3; gTasks[taskId].data[1] = 6; break; case 3: break; case 4: - sub_80FD760(FALSE); - Rfu.unk_04 = 5; + rfu_LMAN_stopManager(0); + Rfu.state = 5; break; case 5: break; case 18: Rfu.unk_cdb = 0; - sub_80FEA10(sub_80F8DA8); + rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); sub_80F8AA4(); sub_80F8AEC(); - Rfu.unk_04 = 20; + Rfu.state = 20; gTasks[taskId].data[1] = 8; CreateTask(sub_80FA834, 5); DestroyTask(taskId); @@ -282,7 +286,7 @@ static void sub_80F887C(s32 r2, s32 r5) { if (r2 & 1) { - Rfu.unk_cde[i] = r4; + Rfu.linkPlayerIdx[i] = r4; r4++; } } @@ -293,12 +297,12 @@ static void sub_80F887C(s32 r2, s32 r5) { if (!(r1 & 1)) { - Rfu.unk_cde[i] = 0; + Rfu.linkPlayerIdx[i] = 0; } } for (r4 = 4; r4 != 0; r4--) { - for (i = 0; i < RFU_CHILD_MAX && Rfu.unk_cde[i] != r4; i++); + for (i = 0; i < RFU_CHILD_MAX && Rfu.linkPlayerIdx[i] != r4; i++); if (i == 4) { r6 = r4; @@ -308,26 +312,26 @@ static void sub_80F887C(s32 r2, s32 r5) { if (r5 & 1) { - Rfu.unk_cde[i] = r6++; + Rfu.linkPlayerIdx[i] = r6++; } } } } -static void sub_80F893C(u8 taskId) +static void Task_JoinGroupSearchForParent(u8 taskId) { - switch (Rfu.unk_04) + switch (Rfu.state) { case 0: - sub_80FD4B0(&sRfuReqConfigTemplate); - Rfu.unk_04 = 1; + rfu_LMAN_initializeRFU((INIT_PARAM*)&sRfuReqConfigTemplate); + Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 6: - sub_80FD538(Rfu.unk_0c, 0, 0xf0, gUnknown_843EC8C); - Rfu.unk_04 = 7; + rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos); + Rfu.state = 7; gTasks[taskId].data[1] = 7; break; case 7: @@ -339,11 +343,11 @@ static void sub_80F893C(u8 taskId) switch (sub_80FA788()) { case 5: - Rfu.unk_04 = 12; + Rfu.state = 12; break; case 6: case 9: - sub_80FEB14(); + rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 2; DestroyTask(taskId); break; @@ -351,15 +355,15 @@ static void sub_80F893C(u8 taskId) break; case 12: { - u8 r5 = 1 << Rfu.unk_c3e; - rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, Rfu.unk_c3e); - rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); - rfu_UNI_setSendData(r5, Rfu.unk_4c, sizeof(Rfu.unk_4c)); + u8 bmChildSlot = 1 << Rfu.child_slot; + rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, Rfu.child_slot); + rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); + rfu_UNI_setSendData(bmChildSlot, Rfu.unk_4c, sizeof(Rfu.unk_4c)); gTasks[taskId].data[1] = 8; DestroyTask(taskId); if (gUnknown_203AC08.unk_0f == 0) { - sub_80FC208(); + rfu_dbg_clear(); gUnknown_203AC08.unk_0f++; } CreateTask(sub_80FA834, 5); @@ -371,56 +375,56 @@ static void sub_80F893C(u8 taskId) static void sub_80F8AA4(void) { u8 i; - u8 r5 = gUnknown_3005E10.unk_00; + u8 acceptSlot = lman.acceptSlot_flag; for (i = 0; i < RFU_CHILD_MAX; i++) { - if (r5 & 1) + if (acceptSlot & 1) { rfu_setRecvBuffer(TYPE_UNI, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i])); rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, i); } - r5 >>= 1; + acceptSlot >>= 1; } } static void sub_80F8AEC(void) { - u8 r5 = gUnknown_3005E10.unk_00; - rfu_UNI_setSendData(r5, Rfu.unk_c87, sizeof(Rfu.unk_c87)); - Rfu.unk_cda = sub_80F886C(r5); - Rfu.unk_ce2 = r5; - sub_80F887C(r5, -1); - Rfu.unk_0c = 1; + u8 acceptSlot = lman.acceptSlot_flag; + rfu_UNI_setSendData(acceptSlot, Rfu.recvCmds, sizeof(Rfu.recvCmds)); + Rfu.unk_cda = sub_80F886C(acceptSlot); + Rfu.bm_PartnerFlags = acceptSlot; + sub_80F887C(acceptSlot, -1); + Rfu.parent_child = MODE_PARENT; } -static void sub_80F8B34(u8 taskId) +static void Task_LinkRfu_UnionRoomListen(u8 taskId) { - if (sub_80F9800()->unk_0a_0 == 0x54 && sub_80FB9F4() == 4) + if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM) && RfuGetErrorStatus() == 4) { - rfu_REQ_disconnect(gUnknown_3005E10.unk_00); + rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); - sub_80FB9E4(0, 0); + RfuSetErrorStatus(0, 0); } - switch (Rfu.unk_04) + switch (Rfu.state) { case 0: - sub_80FD4B0(&sRfuReqConfig); - Rfu.unk_04 = 1; + rfu_LMAN_initializeRFU(&sRfuReqConfig); + Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 17: - sub_80FD538(2, 0, 240, gUnknown_843EC8C); - sub_80FEA10(sub_80F8D20); - Rfu.unk_04 = 18; + rfu_LMAN_establishConnection(2, 0, 240, (u16*)sAcceptedSerialNos); + rfu_LMAN_setMSCCallback(MscCallback_Child); + Rfu.state = 18; break; case 18: break; case 13: - if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0) + if (rfu_UNI_setSendData(1 << Rfu.child_slot, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0) { - Rfu.unk_0c = 0; + Rfu.parent_child = MODE_CHILD; DestroyTask(taskId); if (gTasks[taskId].data[7]) { @@ -433,20 +437,20 @@ static void sub_80F8B34(u8 taskId) } break; case 14: - sub_80FD760(0); - Rfu.unk_04 = 15; + rfu_LMAN_stopManager(0); + Rfu.state = 15; break; case 15: break; case 16: Rfu.unk_cdb = 0; - sub_80FEA10(sub_80F8DA8); - sub_80FAFE0(1); + rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); + UpdateGameData_GroupLockedIn(1); sub_80F8AA4(); sub_80F8AEC(); - Rfu.unk_04 = 20; + Rfu.state = 20; gTasks[taskId].data[1] = 8; - Rfu.unk_0c = 1; + Rfu.parent_child = MODE_PARENT; CreateTask(sub_80FA834, 5); Rfu.unk_ce8 = TRUE; DestroyTask(taskId); @@ -454,17 +458,17 @@ static void sub_80F8B34(u8 taskId) } } -void sub_80F8CFC(void) +void LinkRfu_CreateConnectionAsParent(void) { - sub_80FD538(1, 0, 240, gUnknown_843EC8C); + rfu_LMAN_establishConnection(MODE_PARENT, 0, 240, (u16*)sAcceptedSerialNos); } -void sub_80F8D14(void) +void LinkRfu_StopManagerBeforeEnteringChat(void) { - sub_80FD760(FALSE); + rfu_LMAN_stopManager(0); } -static void sub_80F8D20(u16 unused) +static void MscCallback_Child(u16 unused) { s32 i; @@ -474,53 +478,53 @@ static void sub_80F8D20(u16 unused) } rfu_REQ_recvData(); rfu_waitREQComplete(); - if (gRfuSlotStatusUNI[Rfu.unk_c3e]->recv.newDataFlag) + if (gRfuSlotStatusUNI[Rfu.child_slot]->recv.newDataFlag) { Rfu.unk_cd0++; - sub_80FC588(&Rfu.unk_124, Rfu.unk_c3f); + RFU_queue_20_70_recv(&Rfu.unk_124, Rfu.unk_c3f); gUnknown_203AC08.unk_06++; sub_80F906C(); - rfu_UNI_readySendData(Rfu.unk_c3e); - rfu_UNI_clearRecvNewDataFlag(Rfu.unk_c3e); + rfu_UNI_readySendData(Rfu.child_slot); + rfu_UNI_clearRecvNewDataFlag(Rfu.child_slot); } - LinkRfu_REQ_SendData_HandleParentRelationship(TRUE); + rfu_LMAN_REQ_sendData(TRUE); } -static void sub_80F8DA8(u16 unused) +static void MSCCallback_SetUnkCDB(u16 unused) { Rfu.unk_cdb = 1; } -void sub_80F8DC0(void) +void LinkRfu_Shutdown(void) { u8 i; if (gQuestLogState == 2 || gQuestLogState == 3) return; - sub_80FD52C(); - if (Rfu.unk_0c == 1) + rfu_LMAN_powerDownRFU(); + if (Rfu.parent_child == MODE_PARENT) { - if (FuncIsActiveTask(sub_80F8738) == TRUE) + if (FuncIsActiveTask(Task_LinkLeaderSearchForChildren) == TRUE) { DestroyTask(Rfu.unk_67); - sub_80F85F8(); + ResetLinkRfuGFLayer(); } } - else if (Rfu.unk_0c == 0) + else if (Rfu.parent_child == MODE_CHILD) { - if (FuncIsActiveTask(sub_80F893C) == TRUE) + if (FuncIsActiveTask(Task_JoinGroupSearchForParent) == TRUE) { DestroyTask(Rfu.unk_67); - sub_80F85F8(); + ResetLinkRfuGFLayer(); } } - else if (Rfu.unk_0c == 2) + else if (Rfu.parent_child == 2) { - if (FuncIsActiveTask(sub_80F8B34) == TRUE) + if (FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) { DestroyTask(Rfu.unk_67); - sub_80F85F8(); + ResetLinkRfuGFLayer(); } } for (i = 0; i < NELEMS(gUnknown_843ED88); i++) @@ -532,59 +536,59 @@ void sub_80F8DC0(void) } } -static void sub_80F8E74(void) +static void CreateTask_LinkLeaderSearchForChildren(void) { if (gQuestLogState == 2 || gQuestLogState == 3) return; - Rfu.unk_67 = CreateTask(sub_80F8738, 1); + Rfu.unk_67 = CreateTask(Task_LinkLeaderSearchForChildren, 1); } -static bool8 sub_80F8EA4(void) +static bool8 RfuStateIs7AndPlayerIsChild(void) { - if (Rfu.unk_04 == 7 && Rfu.unk_ccd) + if (Rfu.state == 7 && Rfu.parentId) { return TRUE; } return FALSE; } -static bool32 sub_80F8ECC(void) +static bool32 IsParentSuccessfullyReconnected(void) { - if (Rfu.unk_04 == 7 && !sub_80FD610(gRfuLinkStatus->partner[Rfu.unk_c3d].id, 240)) + if (Rfu.state == 7 && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[Rfu.reconnectedParentIdx].id, 240)) { - Rfu.unk_04 = 9; + Rfu.state = 9; return TRUE; } return FALSE; } -static void sub_80F8F10(void) +static void CreateTask_JoinGroupSearchForParent(void) { if (gQuestLogState == 2 || gQuestLogState == 3) return; - Rfu.unk_67 = CreateTask(sub_80F893C, 1); + Rfu.unk_67 = CreateTask(Task_JoinGroupSearchForParent, 1); } -bool8 sub_80F8F40(void) +bool8 LmanAcceptSlotFlagIsNotZero(void) { - if (gUnknown_3005E10.unk_00) + if (lman.acceptSlot_flag) { return TRUE; } return FALSE; } -void sub_80F8F5C(void) +void LinkRfu_StopManagerAndFinalizeSlots(void) { - Rfu.unk_04 = 4; - Rfu.unk_ce7 = gUnknown_3005E10.unk_00; + Rfu.state = 4; + Rfu.acceptSlot_flag = lman.acceptSlot_flag; } -bool32 sub_80F8F7C(bool32 a0) +bool32 WaitRfuState(bool32 force) { - if (Rfu.unk_04 == 17 || a0) + if (Rfu.state == 17 || force) { - Rfu.unk_04 = 18; + Rfu.state = 18; return TRUE; } return FALSE; @@ -592,7 +596,7 @@ bool32 sub_80F8F7C(bool32 a0) void sub_80F8FA0(void) { - Rfu.unk_04 = 14; + Rfu.state = 14; } static void sub_80F8FAC(u8 a0) @@ -616,11 +620,11 @@ static void sub_80F8FD4(void) for (i = 0; i < 5; i++) { - struct UnkRfuStruct_2 *ptr = &Rfu; + GF_RFU_MANAGER *ptr = &Rfu; for (j = 0; j < 7; j++) { - ptr->unk_c87[i][j][1] = gRecvCmds[i][j] >> 8; - ptr->unk_c87[i][j][0] = gRecvCmds[i][j]; + ptr->recvCmds[i][j][1] = gRecvCmds[i][j] >> 8; + ptr->recvCmds[i][j][0] = gRecvCmds[i][j]; } } CpuFill16(0, gRecvCmds, sizeof gRecvCmds); @@ -643,8 +647,8 @@ static void sub_80F906C(void) { if (Rfu.unk_c3c) { - u8 r2 = sub_80FC888(&Rfu.unk_c1c, Rfu.unk_4c); - if (Rfu.unk_c1c.unk_1e == 0) + u8 r2 = RFU_queue_2_14_send(&Rfu.unk_c1c, Rfu.unk_4c); + if (Rfu.unk_c1c.count == 0) { Rfu.unk_c3c = 0; } @@ -655,8 +659,8 @@ static void sub_80F906C(void) } if (Rfu.unk_c3c == 0) { - sub_80FC79C(&Rfu.unk_9e8, Rfu.unk_4c); - sub_80FC828(&Rfu.unk_c1c, Rfu.unk_4c); + RFU_queue_40_14_send(&Rfu.unk_9e8, Rfu.unk_4c); + RFU_queue_2_14_recv(&Rfu.unk_c1c, Rfu.unk_4c); } } @@ -684,39 +688,39 @@ bool32 IsRfuRecvQueueEmpty(void) static bool32 sub_80F911C(void) { - if (Rfu.unk_04 < 20) + if (Rfu.state < 20) { rfu_REQ_recvData(); rfu_waitREQComplete(); - LinkRfu_REQ_SendData_HandleParentRelationship(FALSE); + rfu_LMAN_REQ_sendData(FALSE); } else { Rfu.unk_cdb = 0; - if ((Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag) == Rfu.unk_ce2 && (Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag)) + if ((Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag) == Rfu.bm_PartnerFlags && (Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag)) { if (!Rfu.unk_cdc) { - if (Rfu.unk_ce3) + if (Rfu.bm_DisconnectSlot) { - sub_80FBCF8(Rfu.unk_ce3); - Rfu.unk_ce3 = 0; + RfuReqDisconnectSlot(Rfu.bm_DisconnectSlot); + Rfu.bm_DisconnectSlot = 0; if (Rfu.unk_ce4 == 1) { - sub_80FB9E4(2, 0x8000); - sub_80FB0E8(0x8000); + RfuSetErrorStatus(2, 0x8000); + GetLinkmanErrorParams(0x8000); return FALSE; } - if (!gUnknown_3005E10.unk_00) + if (!lman.acceptSlot_flag) { - sub_80F8DC0(); + LinkRfu_Shutdown(); gReceivedRemoteLinkPlayers = 0; return FALSE; } } sub_80F8FD4(); rfu_UNI_readySendData(Rfu.unk_cda); - LinkRfu_REQ_SendData_HandleParentRelationship(TRUE); + rfu_LMAN_REQ_sendData(TRUE); } else { @@ -736,23 +740,23 @@ static bool32 sub_80F9204(void) u16 j; u8 retval; - if (Rfu.unk_04 >= 20 && Rfu.unk_0e == 1) + if (Rfu.state >= 20 && Rfu.unk_0e == 1) { rfu_waitREQComplete(); while (Rfu.unk_cdb == 0) { - if (Rfu.unk_ee != 0) + if (Rfu.errorState != 0) { return FALSE; } } rfu_REQ_recvData(); rfu_waitREQComplete(); - if ((gUnknown_3005E10.unk_03 & Rfu.unk_ce2) == Rfu.unk_ce2) + if ((lman.parentAck_flag & Rfu.bm_PartnerFlags) == Rfu.bm_PartnerFlags) { Rfu.unk_cdc = 0; gUnknown_203AC08.unk_06++; - flags = gUnknown_3005E10.unk_00; + flags = lman.acceptSlot_flag; for (i = 0; i < RFU_CHILD_MAX; i++) { if (flags & 1) @@ -762,14 +766,14 @@ static bool32 sub_80F9204(void) if (Rfu.unk_cee[i] != 0xFF && (Rfu.unk_14[i][0] >> 5) != ((Rfu.unk_cee[i] + 1) & 7)) { if (++Rfu.unk_cea[i] > 4) - sub_80FB0E8(0x8100); + GetLinkmanErrorParams(0x8100); } else { Rfu.unk_cee[i] = Rfu.unk_14[i][0] / 32; Rfu.unk_cea[i] = 0; Rfu.unk_14[i][0] &= 0x1f; - r0 = Rfu.unk_cde[i]; + r0 = Rfu.linkPlayerIdx[i]; for (j = 0; j < 7; j++) { gRecvCmds[r0][j] = (Rfu.unk_14[i][(j << 1) + 1] << 8) | Rfu.unk_14[i][(j << 1) + 0]; @@ -783,7 +787,7 @@ static bool32 sub_80F9204(void) flags >>= 1; } sub_80F9038(); - sub_80F9868(0); + RfuHandleReceiveCommand(0); CallRfuFunc(); if (Rfu.unk_ce5 && !Rfu.unk_cd9) { @@ -796,13 +800,13 @@ static bool32 sub_80F9204(void) rfu_setRecvBuffer(TYPE_UNI, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i])); } } - sub_80F887C(Rfu.unk_ce2, Rfu.unk_ce2 | Rfu.unk_ce5); + sub_80F887C(Rfu.bm_PartnerFlags, Rfu.bm_PartnerFlags | Rfu.unk_ce5); Rfu.unk_ce9 = Rfu.unk_ce5; - Rfu.unk_ce2 |= Rfu.unk_ce5; + Rfu.bm_PartnerFlags |= Rfu.unk_ce5; Rfu.unk_ce5 = 0; - rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, sizeof(Rfu.unk_c87)); - Rfu.unk_cda = sub_80F886C(Rfu.unk_ce2); - CreateTask(sub_80FAA94, 0); + rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, sizeof(Rfu.recvCmds)); + Rfu.unk_cda = sub_80F886C(Rfu.bm_PartnerFlags); + CreateTask(Task_ExchangeLinkPlayers, 0); } } else @@ -837,7 +841,7 @@ static void sub_80F94BC(u16 *a0, u8 *a1) } } -static bool32 sub_80F9514(void) +static bool32 RfuProcessEnqueuedRecvBlock(void) { u8 i; u8 j; @@ -845,7 +849,7 @@ static bool32 sub_80F9514(void) u8 sp48[2 * (CMD_LENGTH - 1)]; u8 switchval; - sub_80FC6E8(&Rfu.unk_124, sp00); + RFU_queue_20_70_send(&Rfu.unk_124, sp00); for (i = 0; i < MAX_RFU_PLAYERS; i++) { for (j = 0; j < CMD_LENGTH - 1; j++) @@ -853,23 +857,23 @@ static bool32 sub_80F9514(void) gRecvCmds[i][j] = (sp00[i * 14 + (j << 1) + 1] << 8) | sp00[i * 14 + (j << 1) + 0]; } } - sub_80F9868(0); - if (gUnknown_3005E10.unk_02 == 0 && Rfu.unk_ce4) + RfuHandleReceiveCommand(0); + if (lman.childClockSlave_flag == 0 && Rfu.unk_ce4) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); - switchval = sub_80FB9F4(); + switchval = RfuGetErrorStatus(); if (switchval != 1 && switchval != 6 && switchval != 9) - sub_80FB9E4(2, 0x9000); + RfuSetErrorStatus(2, 0x9000); rfu_clearAllSlot(); gReceivedRemoteLinkPlayers = FALSE; Rfu.RfuFunc = NULL; if (Rfu.unk_ce4 == 1) { - sub_80FB9E4(2, 0x9000); - sub_80FB0E8(0x9000); + RfuSetErrorStatus(2, 0x9000); + GetLinkmanErrorParams(0x9000); } - gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + lman.state = lman.next_state = 0; Rfu.unk_ce4 = 0; } if (Rfu.unk_cd0) @@ -877,36 +881,36 @@ static bool32 sub_80F9514(void) Rfu.unk_cd0--; CallRfuFunc(); sub_80F94BC(gSendCmd, sp48); - sub_80FC63C(&Rfu.unk_9e8, sp48); + RFU_queue_40_14_recv(&Rfu.unk_9e8, sp48); for (i = 0; i < CMD_LENGTH - 1; i++) gSendCmd[i] = 0; } return IsRfuRecvQueueEmpty(); } -static void sub_80F965C(u8 unused, u32 flags) +static void HandleSendFailure(u8 unused, u32 flags) { s32 i, j; - const u8 *r10 = Rfu.unk_6c.unk_04; - for (i = 0; i < Rfu.unk_6c.unk_02; i++) + const u8 *r10 = Rfu.cmd_8800_sendbuf.payload; + for (i = 0; i < Rfu.cmd_8800_sendbuf.count; i++) { if (!(flags & 1)) { - gUnknown_3002008[0] = (~0x76ff) | i; + sResendBlock16[0] = RFU_COMMAND_0x8900 | i; for (j = 0; j < 7; j++) { - gUnknown_3002008[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0]; + sResendBlock16[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0]; } for (j = 0; j < 7; j++) { - gUnknown_3001FF8[2 * j + 1] = gUnknown_3002008[j] >> 8; - gUnknown_3001FF8[2 * j + 0] = gUnknown_3002008[j]; + sResendBlock8[2 * j + 1] = sResendBlock16[j] >> 8; + sResendBlock8[2 * j + 0] = sResendBlock16[j]; j++;j--; // Needed to match; } - sub_80FC63C(&Rfu.unk_9e8, gUnknown_3001FF8); - Rfu.unk_6c.unk_0c |= (1 << i); + RFU_queue_40_14_recv(&Rfu.unk_9e8, sResendBlock8); + Rfu.cmd_8800_sendbuf.failedFlags |= (1 << i); } flags >>= 1; } @@ -914,7 +918,7 @@ static void sub_80F965C(u8 unused, u32 flags) void Rfu_SetBlockReceivedFlag(u8 a0) { - if (Rfu.unk_0c == 1 && a0) + if (Rfu.parent_child == MODE_PARENT && a0) Rfu.unk_61[a0] = 1; else Rfu.unk_5c[a0] = 1; @@ -923,23 +927,23 @@ void Rfu_SetBlockReceivedFlag(u8 a0) void Rfu_ResetBlockReceivedFlag(u8 a0) { Rfu.unk_5c[a0] = 0; - Rfu.unk_80[a0].unk_12 = 0; + Rfu.cmd_8800_recvbuf[a0].receiving = 0; } static u8 sub_80F9770(const u8 *a0) { u8 i; - if (Rfu.unk_0c == 1) + if (Rfu.parent_child == MODE_PARENT) return FALSE; for (i = 0; i < RFU_CHILD_MAX; i++) { - Rfu.unk_cde[i] = a0[i]; + Rfu.linkPlayerIdx[i] = a0[i]; } - return a0[Rfu.unk_c3e]; + return a0[Rfu.child_slot]; } -static void rfu_func_080F97B8(void) +static void RfuFunc_SendKeysToRfu(void) { static u8 gUnknown_3001188; if (gReceivedRemoteLinkPlayers @@ -948,24 +952,24 @@ static void rfu_func_080F97B8(void) { gUnknown_3001188++; gHeldKeyCodeToSend |= (gUnknown_3001188 << 8); - sub_80F9D04(0xbe00); + RfuPrepareSendBuffer(RFU_COMMAND_0xbe00); } } -struct GFtgtGname *sub_80F9800(void) +struct GFtgtGname *GetHostRFUtgtGname(void) { return &gHostRFUtgtGnameBuffer; } bool32 IsSendingKeysToRfu(void) { - return Rfu.RfuFunc == rfu_func_080F97B8; + return Rfu.RfuFunc == RfuFunc_SendKeysToRfu; } -void sub_80F9828(void) +void StartSendingKeysToRfu(void) { AGB_ASSERT_EX(Rfu.RfuFunc == NULL, ABSPATH("rfu.c"), 1473); - Rfu.RfuFunc = rfu_func_080F97B8; + Rfu.RfuFunc = RfuFunc_SendKeysToRfu; } void Rfu_set_zero(void) @@ -973,7 +977,7 @@ void Rfu_set_zero(void) Rfu.RfuFunc = NULL; } -static void sub_80F9868(u8 unused) +static void RfuHandleReceiveCommand(u8 unused) { u16 i; u16 j; @@ -982,63 +986,63 @@ static void sub_80F9868(u8 unused) { switch (gRecvCmds[i][0] & 0xff00) { - case 0x7800: - if (Rfu.unk_0c == 0 && gReceivedRemoteLinkPlayers != 0) + case RFU_COMMAND_0x7800: + if (Rfu.parent_child == MODE_CHILD && gReceivedRemoteLinkPlayers != 0) return; // fallthrough - case 0x7700: + case RFU_COMMAND_0x7700: if (gRfuLinkStatus->parentChild == MODE_CHILD) { Rfu.playerCount = gRecvCmds[i][1]; Rfu.unk_cce = sub_80F9770((u8 *)(gRecvCmds[i] + 2)); } break; - case 0x8800: - if (Rfu.unk_80[i].unk_12 == 0) + case RFU_COMMAND_0x8800: + if (Rfu.cmd_8800_recvbuf[i].receiving == 0) { - Rfu.unk_80[i].unk_00 = 0; - Rfu.unk_80[i].unk_02 = gRecvCmds[i][1]; - Rfu.unk_80[i].unk_11 = gRecvCmds[i][2]; - Rfu.unk_80[i].unk_08 = 0; - Rfu.unk_80[i].unk_12 = 1; + Rfu.cmd_8800_recvbuf[i].next = 0; + Rfu.cmd_8800_recvbuf[i].count = gRecvCmds[i][1]; + Rfu.cmd_8800_recvbuf[i].owner = gRecvCmds[i][2]; + Rfu.cmd_8800_recvbuf[i].receivedFlags = 0; + Rfu.cmd_8800_recvbuf[i].receiving = 1; Rfu.unk_5c[i] = 0; } break; - case 0x8900: - if (Rfu.unk_80[i].unk_12 == 1) + case RFU_COMMAND_0x8900: + if (Rfu.cmd_8800_recvbuf[i].receiving == 1) { - Rfu.unk_80[i].unk_00 = gRecvCmds[i][0] & 0xff; - Rfu.unk_80[i].unk_08 |= (1 << Rfu.unk_80[i].unk_00); + Rfu.cmd_8800_recvbuf[i].next = gRecvCmds[i][0] & 0xff; + Rfu.cmd_8800_recvbuf[i].receivedFlags |= (1 << Rfu.cmd_8800_recvbuf[i].next); for (j = 0; j < 6; j++) - gBlockRecvBuffer[i][Rfu.unk_80[i].unk_00 * 6 + j] = gRecvCmds[i][j + 1]; - if (Rfu.unk_80[i].unk_08 == gUnknown_843EBD4[Rfu.unk_80[i].unk_02]) + gBlockRecvBuffer[i][Rfu.cmd_8800_recvbuf[i].next * 6 + j] = gRecvCmds[i][j + 1]; + if (Rfu.cmd_8800_recvbuf[i].receivedFlags == sAllBlocksReceived[Rfu.cmd_8800_recvbuf[i].count]) { - Rfu.unk_80[i].unk_12 = 2; + Rfu.cmd_8800_recvbuf[i].receiving = 2; Rfu_SetBlockReceivedFlag(i); - if (sub_80F9800()->unk_0a_0 == 0x45 && gReceivedRemoteLinkPlayers != 0 && Rfu.unk_0c == 0) - sub_80FAA58(gBlockRecvBuffer); + if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers != 0 && Rfu.parent_child == MODE_CHILD) + ValidateAndReceivePokemonSioInfo(gBlockRecvBuffer); } } break; - case 0xa100: + case RFU_COMMAND_0xa100: Rfu_InitBlockSend(gUnknown_843EC64[gRecvCmds[i][1]].buffer, (u16)gUnknown_843EC64[gRecvCmds[i][1]].size); break; - case 0x5f00: - Rfu.unk_e4[i] = 1; + case RFU_COMMAND_0x5f00: + Rfu.cmd5f00Ack[i] = 1; break; - case 0x6600: - if (Rfu.unk_100 == gRecvCmds[i][1]) - Rfu.unk_e9[i] = 1; + case RFU_COMMAND_0x6600: + if (Rfu.cmd_6600_count == gRecvCmds[i][1]) + Rfu.cmd_6600_recvd[i] = 1; break; - case 0xed00: - if (Rfu.unk_0c == 0) + case RFU_COMMAND_0xed00: + if (Rfu.parent_child == MODE_CHILD) { if (gReceivedRemoteLinkPlayers != 0) { if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag) { gReceivedRemoteLinkPlayers = 0; - sub_80FEB14(); + rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = gRecvCmds[i][2]; } Rfu.playerCount = gRecvCmds[i][3]; @@ -1047,25 +1051,25 @@ static void sub_80F9868(u8 unused) } else { - sub_80F9D04(0xee00); + RfuPrepareSendBuffer(RFU_COMMAND_0xee00); gSendCmd[1] = gRecvCmds[i][1]; gSendCmd[2] = gRecvCmds[i][2]; gSendCmd[3] = gRecvCmds[i][3]; } break; - case 0xee00: - if (Rfu.unk_0c == 1) + case RFU_COMMAND_0xee00: + if (Rfu.parent_child == MODE_PARENT) { - Rfu.unk_ce3 |= gRecvCmds[i][1]; + Rfu.bm_DisconnectSlot |= gRecvCmds[i][1]; Rfu.unk_ce4 = gRecvCmds[i][2]; sub_80FA9D0(gRecvCmds[i][1]); } break; - case 0xbe00: + case RFU_COMMAND_0xbe00: gLinkPartnersHeldKeys[i] = gRecvCmds[i][1]; break; } - if (Rfu.unk_0c == 1 && Rfu.unk_61[i]) + if (Rfu.parent_child == MODE_PARENT && Rfu.unk_61[i]) { if (Rfu.unk_61[i] == 4) { @@ -1078,13 +1082,13 @@ static void sub_80F9868(u8 unused) } } -static bool8 sub_80F9C50(void) +static bool8 Cmd8000recvIsFinished(void) { s32 i; for (i = 0; i < 5; i++) { - if (Rfu.unk_80[i].unk_12) + if (Rfu.cmd_8800_recvbuf[i].receiving) return FALSE; } return TRUE; @@ -1096,21 +1100,21 @@ static bool8 sub_80F9C78(void) for (i = 0; i < Rfu.playerCount; i++) { - if (Rfu.unk_80[i].unk_12 != 2 || Rfu.unk_5c[i] != 1) + if (Rfu.cmd_8800_recvbuf[i].receiving != 2 || Rfu.unk_5c[i] != 1) return FALSE; } return TRUE; } -static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data) +static void ResetSendDataManager(struct RfuBlockSend *data) { - data->unk_00 = 0; - data->unk_02 = 0; - data->unk_04 = NULL; - data->unk_08 = 0; - data->unk_10 = 0; - data->unk_11 = 0; - data->unk_12 = 0; + data->next = 0; + data->count = 0; + data->payload = NULL; + data->receivedFlags = 0; + data->sending = 0; + data->owner = 0; + data->receiving = 0; } u8 Rfu_GetBlockReceivedStatus(void) @@ -1120,7 +1124,7 @@ u8 Rfu_GetBlockReceivedStatus(void) for (i = 0; i < 5; i++) { - if (Rfu.unk_80[i].unk_12 == 2 && Rfu.unk_5c[i] == 1) + if (Rfu.cmd_8800_recvbuf[i].receiving == 2 && Rfu.unk_5c[i] == 1) { flags |= (1 << i); } @@ -1128,7 +1132,7 @@ u8 Rfu_GetBlockReceivedStatus(void) return flags; } -static void sub_80F9D04(u16 command) +static void RfuPrepareSendBuffer(u16 command) { u8 i; u8 *buff; @@ -1137,47 +1141,47 @@ static void sub_80F9D04(u16 command) gSendCmd[0] = command; switch (command) { - case 0x8800: - gSendCmd[1] = Rfu.unk_6c.unk_02; - gSendCmd[2] = Rfu.unk_6c.unk_11 + 0x80; + case RFU_COMMAND_0x8800: + gSendCmd[1] = Rfu.cmd_8800_sendbuf.count; + gSendCmd[2] = Rfu.cmd_8800_sendbuf.owner + 0x80; break; - case 0xa100: - if (sub_80F9C50()) + case RFU_COMMAND_0xa100: + if (Cmd8000recvIsFinished()) gSendCmd[1] = Rfu.unk_5a; break; - case 0x7700: - case 0x7800: - tmp = Rfu.unk_ce2 ^ Rfu.unk_ce3; + case RFU_COMMAND_0x7700: + case RFU_COMMAND_0x7800: + tmp = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; Rfu.playerCount = gUnknown_843EC41[tmp] + 1; gSendCmd[1] = Rfu.playerCount; buff = (u8 *)(gSendCmd + 2); for (i = 0; i < RFU_CHILD_MAX; i++) - buff[i] = Rfu.unk_cde[i]; + buff[i] = Rfu.linkPlayerIdx[i]; break; - case 0x6600: - case 0x5f00: - gSendCmd[1] = Rfu.unk_100; + case RFU_COMMAND_0x6600: + case RFU_COMMAND_0x5f00: + gSendCmd[1] = Rfu.cmd_6600_count; break; - case 0x2f00: + case RFU_COMMAND_0x2f00: for (i = 0; i < 6; i++) gSendCmd[1 + i] = Rfu.unk_f2[i]; break; - case 0xbe00: + case RFU_COMMAND_0xbe00: gSendCmd[1] = gHeldKeyCodeToSend; break; - case 0xee00: + case RFU_COMMAND_0xee00: break; - case 0xed00: + case RFU_COMMAND_0xed00: break; } } -void sub_80F9E2C(void *a0) +void RfuPrepareSend0x2f00(void * data) { - if (gSendCmd[0] == 0 && !sub_80FBA00()) + if (gSendCmd[0] == 0 && !RfuIsErrorStatus1or2()) { - memcpy(Rfu.unk_f2, a0, sizeof(Rfu.unk_f2)); - sub_80F9D04(0x2f00); + memcpy(Rfu.unk_f2, data, sizeof(Rfu.unk_f2)); + RfuPrepareSendBuffer(RFU_COMMAND_0x2f00); } } @@ -1189,77 +1193,77 @@ bool32 Rfu_InitBlockSend(const u8 *src, size_t size) return FALSE; if (gSendCmd[0] != 0) return FALSE; - if (Rfu.unk_6c.unk_10 != 0) + if (Rfu.cmd_8800_sendbuf.sending != 0) { gUnknown_203AC08.unk_83++; return FALSE; } r4 = (size % 12) != 0; - Rfu.unk_6c.unk_11 = GetMultiplayerId(); - Rfu.unk_6c.unk_10 = 1; - Rfu.unk_6c.unk_02 = (size / 12) + r4; - Rfu.unk_6c.unk_00 = 0; - if (size > 0x100) - Rfu.unk_6c.unk_04 = src; + Rfu.cmd_8800_sendbuf.owner = GetMultiplayerId(); + Rfu.cmd_8800_sendbuf.sending = 1; + Rfu.cmd_8800_sendbuf.count = (size / 12) + r4; + Rfu.cmd_8800_sendbuf.next = 0; + if (size > 0x100) // should never be reached + Rfu.cmd_8800_sendbuf.payload = src; else { if (src != gBlockSendBuffer) memcpy(gBlockSendBuffer, src, size); - Rfu.unk_6c.unk_04 = gBlockSendBuffer; + Rfu.cmd_8800_sendbuf.payload = gBlockSendBuffer; } - sub_80F9D04(0x8800); - Rfu.RfuFunc = rfufunc_80F9F44; + RfuPrepareSendBuffer(RFU_COMMAND_0x8800); + Rfu.RfuFunc = RfuFunc_HandleBlockSend; Rfu.unk_5b = 0; return TRUE; } -static void rfufunc_80F9F44(void) +static void RfuFunc_HandleBlockSend(void) { if (gSendCmd[0] == 0) { - sub_80F9D04(0x8800); - if (Rfu.unk_0c == 1) + RfuPrepareSendBuffer(RFU_COMMAND_0x8800); + if (Rfu.parent_child == MODE_PARENT) { if (++Rfu.unk_5b > 2) - Rfu.RfuFunc = sub_80F9FA8; + Rfu.RfuFunc = RfuFunc_SendNextBlock; } else { - if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == 0x8800) - Rfu.RfuFunc = sub_80F9FA8; + if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFU_COMMAND_0x8800) + Rfu.RfuFunc = RfuFunc_SendNextBlock; } } } -static void sub_80F9FA8(void) +static void RfuFunc_SendNextBlock(void) { s32 i; - const u8 *src = Rfu.unk_6c.unk_04; - gSendCmd[0] = 0x8900 | Rfu.unk_6c.unk_00; + const u8 *src = Rfu.cmd_8800_sendbuf.payload; + gSendCmd[0] = RFU_COMMAND_0x8900 | Rfu.cmd_8800_sendbuf.next; for (i = 0; i < 7; i++) - gSendCmd[i + 1] = (src[(i << 1) + Rfu.unk_6c.unk_00 * 12 + 1] << 8) | src[(i << 1) + Rfu.unk_6c.unk_00 * 12 + 0]; - Rfu.unk_6c.unk_00++; - if (Rfu.unk_6c.unk_02 <= Rfu.unk_6c.unk_00) + gSendCmd[i + 1] = (src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 1] << 8) | src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 0]; + Rfu.cmd_8800_sendbuf.next++; + if (Rfu.cmd_8800_sendbuf.count <= Rfu.cmd_8800_sendbuf.next) { - Rfu.unk_6c.unk_10 = 0; - Rfu.RfuFunc = rfufunc_80FA020; + Rfu.cmd_8800_sendbuf.sending = 0; + Rfu.RfuFunc = RfuFunc_SendLastBlock; } } -static void rfufunc_80FA020(void) +static void RfuFunc_SendLastBlock(void) { - const u8 *src = Rfu.unk_6c.unk_04; + const u8 *src = Rfu.cmd_8800_sendbuf.payload; u8 mpId = GetMultiplayerId(); s32 i; - if (Rfu.unk_0c == 0) + if (Rfu.parent_child == MODE_CHILD) { - gSendCmd[0] = (~0x76ff) | (Rfu.unk_6c.unk_02 - 1); + gSendCmd[0] = RFU_COMMAND_0x8900 | (Rfu.cmd_8800_sendbuf.count - 1); for (i = 0; i < 7; i++) - gSendCmd[i + 1] = (src[(i << 1) + (Rfu.unk_6c.unk_02 - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.unk_6c.unk_02 - 1) * 12 + 0]; - if ((u8)gRecvCmds[mpId][0] == Rfu.unk_6c.unk_02 - 1) + gSendCmd[i + 1] = (src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 0]; + if ((u8)gRecvCmds[mpId][0] == Rfu.cmd_8800_sendbuf.count - 1) { - if (Rfu.unk_80[mpId].unk_08 != gUnknown_843EBD4[Rfu.unk_80[mpId].unk_02]) + if (Rfu.cmd_8800_recvbuf[mpId].receivedFlags != sAllBlocksReceived[Rfu.cmd_8800_recvbuf[mpId].count]) { - sub_80F965C(mpId, Rfu.unk_80[mpId].unk_08); + HandleSendFailure(mpId, Rfu.cmd_8800_recvbuf[mpId].receivedFlags); gUnknown_203AC08.unk_64++; } else @@ -1273,45 +1277,45 @@ static void rfufunc_80FA020(void) bool8 sub_80FA0F8(u8 a0) { Rfu.unk_5a = a0; - sub_80F9D04(0xa100); + RfuPrepareSendBuffer(RFU_COMMAND_0xa100); return TRUE; } -static void sub_80FA114(void) +static void RfuFunc_End5F00_PowerDownRfu(void) { rfu_clearAllSlot(); - sub_80FD52C(); + rfu_LMAN_powerDownRFU(); gReceivedRemoteLinkPlayers = 0; Rfu.unk_ef = 1; Rfu.RfuFunc = NULL; } -static void sub_80FA140(void) +static void RfuFunc_End5F00_ParentDisconnect(void) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); - sub_80FA114(); + RfuFunc_End5F00_PowerDownRfu(); } -static void sub_80FA160(void) +static void RfuFunc_End5F00(void) { - if (Rfu.unk_0c == 0) + if (Rfu.parent_child == MODE_CHILD) { - sub_80FEB14(); + rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 2; } else - Rfu.RfuFunc = sub_80FA140; + Rfu.RfuFunc = RfuFunc_End5F00_ParentDisconnect; } void LinkRfu_FatalError(void) { - sub_80FEB14(); + rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 1; - Rfu.unk_ce3 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + Rfu.bm_DisconnectSlot = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; } -static void sub_80FA1C4(void) +static void RfuFunc_WaitAck5F00(void) { s32 i; u8 playerCount = Rfu.playerCount; @@ -1319,132 +1323,132 @@ static void sub_80FA1C4(void) for (i = 0; i < MAX_RFU_PLAYERS; i++) { - if (Rfu.unk_e4[i]) + if (Rfu.cmd5f00Ack[i]) count++; } if (count == playerCount) { - gBattleTypeFlags &= (u16)~BATTLE_TYPE_20; - if (Rfu.unk_0c == 0) + gBattleTypeFlags &= ~(BATTLE_TYPE_20 | 0xFFFF0000); + if (Rfu.parent_child == MODE_CHILD) { - Rfu.unk_ee = 3; - sub_80FA160(); + Rfu.errorState = 3; + RfuFunc_End5F00(); } else - Rfu.RfuFunc = sub_80FA160; + Rfu.RfuFunc = RfuFunc_End5F00; } } -static void sub_80FA224(void) +static void RfuFunc_BuildCommand5F00(void) { if (gSendCmd[0] == 0 && !Rfu.unk_ce8) { - sub_80F9D04(0x5f00); - Rfu.RfuFunc = sub_80FA1C4; + RfuPrepareSendBuffer(RFU_COMMAND_0x5f00); + Rfu.RfuFunc = RfuFunc_WaitAck5F00; } } -static void sub_80FA25C(u8 taskId) +static void Task_WaitRfuFuncAndSetBuildCmd5F00(u8 taskId) { if (Rfu.RfuFunc == NULL) { Rfu.unk_cd9 = 1; - Rfu.RfuFunc = sub_80FA224; + Rfu.RfuFunc = RfuFunc_BuildCommand5F00; DestroyTask(taskId); } } -void task_add_05_task_del_08FA224_when_no_RfuFunc(void) +void Rfu_BeginBuildAndSendCommand5F(void) { - if (!FuncIsActiveTask(sub_80FA25C)) - CreateTask(sub_80FA25C, 5); + if (!FuncIsActiveTask(Task_WaitRfuFuncAndSetBuildCmd5F00)) + CreateTask(Task_WaitRfuFuncAndSetBuildCmd5F00, 5); } -static void sub_80FA2B0(void) +static void RfuFunc_Send6600_3(void) { u8 playerCount; u8 i; - if (GetMultiplayerId() != 0) + if (GetMultiplayerId() != 0) // child { - if (Rfu.unk_124.unk_8c2 == 0 && Rfu.unk_fe > 0x3c) + if (Rfu.unk_124.count == 0 && Rfu.cmd_6600_timer > 60) { - sub_80F9D04(0x6600); - Rfu.unk_fe = 0; + RfuPrepareSendBuffer(RFU_COMMAND_0x6600); + Rfu.cmd_6600_timer = 0; } } playerCount = GetLinkPlayerCount(); for (i = 0; i < playerCount; i++) { - if (Rfu.unk_e9[i] == 0) + if (Rfu.cmd_6600_recvd[i] == 0) break; } if (i == playerCount) { for (i = 0; i < MAX_RFU_PLAYERS; i++) - Rfu.unk_e9[i] = 0; - Rfu.unk_100++; + Rfu.cmd_6600_recvd[i] = 0; + Rfu.cmd_6600_count++; Rfu.RfuFunc = NULL; } - Rfu.unk_fe++; + Rfu.cmd_6600_timer++; } -static void sub_80FA350(void) +static void RfuFunc_Send6600_2(void) { - if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0) { - sub_80F9D04(0x6600); - Rfu.RfuFunc = sub_80FA2B0; + RfuPrepareSendBuffer(RFU_COMMAND_0x6600); + Rfu.RfuFunc = RfuFunc_Send6600_3; } } -static void sub_80FA388(void) +static void RfuFunc_Send6600_1(void) { u8 i; u8 playerCount; - if (GetMultiplayerId() != 0) + if (GetMultiplayerId() != 0) // child { - if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0) { - sub_80F9D04(0x6600); - Rfu.RfuFunc = sub_80FA2B0; + RfuPrepareSendBuffer(RFU_COMMAND_0x6600); + Rfu.RfuFunc = RfuFunc_Send6600_3; } } - else + else // parent { playerCount = GetLinkPlayerCount(); for (i = 1; i < playerCount; i++) { - if (Rfu.unk_e9[i] == 0) + if (Rfu.cmd_6600_recvd[i] == 0) break; } if (i == playerCount) { - if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0) { - sub_80F9D04(0x6600); - Rfu.RfuFunc = sub_80FA350; + RfuPrepareSendBuffer(RFU_COMMAND_0x6600); + Rfu.RfuFunc = RfuFunc_Send6600_2; } } } } -void sub_80FA42C(void) +void LinkRfu_SetRfuFuncToSend6600(void) { if (Rfu.RfuFunc == NULL) { - Rfu.RfuFunc = sub_80FA388; - Rfu.unk_fe = 0; + Rfu.RfuFunc = RfuFunc_Send6600_1; + Rfu.cmd_6600_timer = 0; } } -bool32 sub_80FA44C(u32 a0) +bool32 RfuSerialNumberIsValid(u32 serialNo) { s32 i; - for (i = 0; gUnknown_843EC8C[i] != a0; i++) + for (i = 0; sAcceptedSerialNos[i] != serialNo; i++) { - if (gUnknown_843EC8C[i] == 0xFFFF) + if (sAcceptedSerialNos[i] == 0xFFFF) return FALSE; } return TRUE; @@ -1453,20 +1457,20 @@ bool32 sub_80FA44C(u32 a0) u8 sub_80FA484(bool32 a0) { if (!a0) - return sub_80FEA34(0, 0); - sub_80FEA34(1, 0x258); + return rfu_LMAN_setLinkRecovery(0, 0); + rfu_LMAN_setLinkRecovery(1, 600); return 0; } void sub_80FA4A8(void) { Rfu.unk_cd9 = 1; - sub_80FD760(FALSE); + rfu_LMAN_stopManager(0); } u8 LinkRfu_GetMultiplayerId(void) { - if (Rfu.unk_0c == 1) + if (Rfu.parent_child == MODE_PARENT) return 0; return Rfu.unk_cce; } @@ -1507,7 +1511,7 @@ static bool8 sub_80FA528(void) } } - else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED) + else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) { rfu_clearSlot(TYPE_NI_RECV, i); } @@ -1541,9 +1545,9 @@ bool32 sub_80FA5D4(void) return FALSE; } -bool32 sub_80FA634(u16 a0, const u8 *a1) +bool32 TrainerIdAndNameStillInPartnersList(u16 trainerId, const u8 *trainerName) { - u8 r1 = sub_80FBC70(a1, a0); + u8 r1 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (r1 == 0xFF) return TRUE; if (Rfu.unk_cd1[r1] == 9) @@ -1551,27 +1555,27 @@ bool32 sub_80FA634(u16 a0, const u8 *a1) return FALSE; } -void sub_80FA670(u8 a0, u16 a1, const u8 *a2) +void SendByteToPartnerByIdAndName(u8 value, u16 trainerId, const u8 *trainerName) { - u8 r4 = sub_80FBC70(a2, a1); - Rfu.unk_cd1[r4] = a0; - rfu_clearSlot(TYPE_NI_SEND, r4); - rfu_NI_setSendData(1 << r4, 8, Rfu.unk_cd1 + r4, 1); + u8 slotNo = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); + Rfu.unk_cd1[slotNo] = value; + rfu_clearSlot(TYPE_NI_SEND, slotNo); + rfu_NI_setSendData(1 << slotNo, 8, Rfu.unk_cd1 + slotNo, 1); } -void sub_80FA6BC(void) +void LinkRfuNIsend8(void) { Rfu.unk_c85 = 8; - rfu_clearSlot(TYPE_NI_SEND, Rfu.unk_c3e); - rfu_NI_setSendData(1 << Rfu.unk_c3e, 8, &Rfu.unk_c85, 1); + rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot); + rfu_NI_setSendData(1 << Rfu.child_slot, 8, &Rfu.unk_c85, 1); } -u32 sub_80FA6FC(u16 a0, const u8 *a1) +u32 WaitSendByteToPartnerByIdAndName(u16 trainerId, const u8 *trainerName) { - u8 r0 = sub_80FBC70(a1, a0); + u8 r0 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (r0 == 0xFF) return 2; - if (gRfuSlotStatusNI[r0]->send.state == 0) + if (gRfuSlotStatusNI[r0]->send.state == SLOT_STATE_READY) return 1; return 0; } @@ -1597,18 +1601,18 @@ static s32 sub_80FA788(void) s32 retval = 0; if (Rfu.unk_c85 == 8) { - if (gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[Rfu.unk_c3e]->send.state == SLOT_STATE_SEND_FAILED) - rfu_clearSlot(TYPE_NI_SEND, Rfu.unk_c3e); + if (gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_FAILED) + rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot); } - if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) + if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) { - rfu_clearSlot(TYPE_NI_RECV, Rfu.unk_c3e); - sub_80FB9E4(Rfu.unk_c86, 0); + rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot); + RfuSetErrorStatus(Rfu.unk_c86, 0); retval = Rfu.unk_c86; } - else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED) + else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) { - rfu_clearSlot(TYPE_NI_RECV, Rfu.unk_c3e); + rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot); retval = 6; } return retval; @@ -1626,20 +1630,20 @@ static void sub_80FA834(u8 taskId) switch (gTasks[taskId].data[0]) { case 0: - if (sub_80F9C50()) + if (Cmd8000recvIsFinished()) { ResetBlockReceivedFlags(); - sub_800B0B4(); + PrepareLocalLinkPlayerBlock(); gTasks[taskId].data[0]++; } break; case 1: - if (Rfu.unk_0c == 1) + if (Rfu.parent_child == MODE_PARENT) { if (gReceivedRemoteLinkPlayers) - sub_80F9D04(0x7800); + RfuPrepareSendBuffer(RFU_COMMAND_0x7800); else - sub_80F9D04(0x7700); + RfuPrepareSendBuffer(RFU_COMMAND_0x7700); gTasks[taskId].data[0] = 101; } else @@ -1654,12 +1658,12 @@ static void sub_80FA834(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - if (Rfu.unk_0c == 1) + if (Rfu.parent_child == MODE_PARENT) { - if (sub_80F9C50()) + if (Cmd8000recvIsFinished()) { Rfu.unk_5a = 0; - sub_80F9D04(0xa100); + RfuPrepareSendBuffer(RFU_COMMAND_0xa100); gTasks[taskId].data[0]++; } } @@ -1673,7 +1677,7 @@ static void sub_80FA834(u8 taskId) case 5: for (i = 0; i < Rfu.playerCount; i++) { - sub_800B110(i); + LinkPlayerFromBlock(i); Rfu_ResetBlockReceivedFlag(i); } gTasks[taskId].data[0]++; @@ -1682,15 +1686,15 @@ static void sub_80FA834(u8 taskId) DestroyTask(taskId); gReceivedRemoteLinkPlayers = 1; Rfu.unk_ce8 = FALSE; - sub_80FEA34(1, 0x258); - if (Rfu.unk_ce6) + rfu_LMAN_setLinkRecovery(1, 600); + if (Rfu.unionRoomChatters) { for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((Rfu.unk_ce6 >> i) & 1) + if ((Rfu.unionRoomChatters >> i) & 1) { Rfu.unk_ce5 = 1 << i; - Rfu.unk_ce6 ^= (1 << i); + Rfu.unionRoomChatters ^= (1 << i); } } } @@ -1705,39 +1709,39 @@ static void sub_80FA9D0(u16 a0) for (i = 0; i < RFU_CHILD_MAX; i++) { if ((a0 >> i) & 1) - Rfu.unk_cde[i] = 0; + Rfu.linkPlayerIdx[i] = 0; } } -static void sub_80FA9FC(const struct UnkRfuStruct_8010A14 *a0) +static void ReceiveRfuLinkPlayers(const struct SioInfo *chunk) { s32 i; - Rfu.playerCount = a0->unk_0f; + Rfu.playerCount = chunk->playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - Rfu.unk_cde[i] = a0->unk_10[i]; + Rfu.linkPlayerIdx[i] = chunk->linkPlayerIdx[i]; for (i = 0; i < MAX_RFU_PLAYERS; i++) { - gLinkPlayers[i] = a0->unk_14[i]; - sub_800B284(gLinkPlayers + i); + gLinkPlayers[i] = chunk->linkPlayers[i]; + IntlConvertLinkPlayerName(gLinkPlayers + i); } } -static void sub_80FAA58(void *a0) +static void ValidateAndReceivePokemonSioInfo(void *recvBuffer) { - if (strcmp("PokemonSioInfo", ((struct UnkRfuStruct_8010A14 *)a0)->unk_00) == 0) + if (strcmp("PokemonSioInfo", recvBuffer) == 0) { - sub_80FA9FC(a0); - CpuFill16(0, a0, sizeof(struct UnkRfuStruct_8010A14)); + ReceiveRfuLinkPlayers(recvBuffer); + CpuFill16(0, recvBuffer, sizeof(struct SioInfo)); ResetBlockReceivedFlag(0); } } -static void sub_80FAA94(u8 taskId) +static void Task_ExchangeLinkPlayers(u8 taskId) { s32 i; struct LinkPlayerBlock *r2; - struct UnkRfuStruct_8010A14 *r5; - u8 r4 = Rfu.unk_cde[gUnknown_843EC38[Rfu.unk_ce9]]; + struct SioInfo *r5; + u8 r4 = Rfu.linkPlayerIdx[gUnknown_843EC38[Rfu.unk_ce9]]; if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2) { Rfu.unk_ce8 = FALSE; @@ -1749,7 +1753,7 @@ static void sub_80FAA94(u8 taskId) if (gSendCmd[0] == 0) { ResetBlockReceivedFlag(r4); - sub_80F9D04(0x7800); + RfuPrepareSendBuffer(RFU_COMMAND_0x7800); gTasks[taskId].data[0]++; } break; @@ -1763,42 +1767,43 @@ static void sub_80FAA94(u8 taskId) ResetBlockReceivedFlag(r4); r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4]; gLinkPlayers[r4] = r2->linkPlayer; - sub_800B284(gLinkPlayers + r4); + IntlConvertLinkPlayerName(gLinkPlayers + r4); gTasks[taskId].data[0]++; } break; case 3: - r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer; - memcpy(r5->unk_00, "PokemonSioInfo", sizeof("PokemonSioInfo")); - r5->unk_0f = Rfu.playerCount; + // Prepare send block + r5 = (struct SioInfo *)gBlockSendBuffer; + memcpy(r5->magic, "PokemonSioInfo", sizeof("PokemonSioInfo")); + r5->playerCount = Rfu.playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - r5->unk_10[i] = Rfu.unk_cde[i]; - memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers); + r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i]; + memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); gTasks[taskId].data[0]++; // fallthrough case 4: - r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer; - r5->unk_0f = Rfu.playerCount; + r5 = (struct SioInfo *)gBlockSendBuffer; + r5->playerCount = Rfu.playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - r5->unk_10[i] = Rfu.unk_cde[i]; - memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers); + r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i]; + memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); if (SendBlock(0, gBlockSendBuffer, 0xa0)) gTasks[taskId].data[0]++; break; case 5: if (IsLinkTaskFinished() && GetBlockReceivedStatus() & 1) { - CpuFill16(0, gBlockRecvBuffer, sizeof(struct UnkRfuStruct_8010A14)); + CpuFill16(0, gBlockRecvBuffer, sizeof(struct SioInfo)); ResetBlockReceivedFlag(0); Rfu.unk_ce8 = FALSE; - if (Rfu.unk_ce6) + if (Rfu.unionRoomChatters) { for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((Rfu.unk_ce6 >> i) & 1) + if ((Rfu.unionRoomChatters >> i) & 1) { Rfu.unk_ce5 = 1 << i; - Rfu.unk_ce6 ^= (1 << i); + Rfu.unionRoomChatters ^= (1 << i); Rfu.unk_ce8 = TRUE; break; } @@ -1819,7 +1824,7 @@ static void sub_80FACF0(u8 taskId) case 0: if (Rfu.playerCount) { - sub_800B0B4(); + PrepareLocalLinkPlayerBlock(); SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock)); gTasks[taskId].data[0]++; } @@ -1831,7 +1836,7 @@ static void sub_80FACF0(u8 taskId) case 2: if (GetBlockReceivedStatus() & 1) { - sub_80FA9FC((const struct UnkRfuStruct_8010A14 *)gBlockRecvBuffer); + ReceiveRfuLinkPlayers((const struct SioInfo *)gBlockRecvBuffer); ResetBlockReceivedFlag(0); gReceivedRemoteLinkPlayers = 1; DestroyTask(taskId); @@ -1840,51 +1845,51 @@ static void sub_80FACF0(u8 taskId) } } -static void sub_80FAD98(void) +static void RfuCheckErrorStatus(void) { - if (Rfu.unk_ee == 1 && gUnknown_3005E10.unk_02 == 0) + if (Rfu.errorState == 1 && lman.childClockSlave_flag == 0) { if (gMain.callback2 == c2_mystery_gift_e_reader_run) gWirelessCommType = 2; SetMainCallback2(CB2_LinkError); gMain.savedCallback = CB2_LinkError; - sub_800ACBC((Rfu.unk_0a << 16) | (Rfu.unk_10 << 8) | Rfu.unk_12, Rfu.unk_124.unk_8c2, Rfu.unk_9e8.unk_232, sub_80FB9F4() == 2); - Rfu.unk_ee = 2; + SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.unk_9e8.count, RfuGetErrorStatus() == 2); + Rfu.errorState = 2; CloseLink(); } - else if (Rfu.unk_9e8.unk_233 == 1 || Rfu.unk_124.unk_8c3 == 1) + else if (Rfu.unk_9e8.full == 1 || Rfu.unk_124.full == 1) { - if (gUnknown_3005E10.unk_02) - sub_80FEB14(); - sub_80FB9E4(1, 0x7000); - sub_80FB0E8(0x7000); + if (lman.childClockSlave_flag) + rfu_LMAN_requestChangeAgbClockMaster(); + RfuSetErrorStatus(1, 0x7000); + GetLinkmanErrorParams(0x7000); } } static void rfu_REQ_recvData_then_sendData(void) { - if (gUnknown_3005E10.unk_06 == 1) + if (lman.parent_child == MODE_PARENT) { rfu_REQ_recvData(); rfu_waitREQComplete(); - LinkRfu_REQ_SendData_HandleParentRelationship(0); + rfu_LMAN_REQ_sendData(RFU_CHILD_CLOCK_SLAVE_OFF); } } -bool32 sub_80FAE94(void) +bool32 LinkRfuMain1(void) { bool32 retval = FALSE; - Rfu.unk_ccd = 0; - sub_80FDA30(Random()); + Rfu.parentId = 0; + rfu_LMAN_manager_entity(Random()); if (Rfu.unk_ef == 0) { - switch (Rfu.unk_0c) + switch (Rfu.parent_child) { case 1: sub_80F911C(); break; case 0: - retval = sub_80F9514(); + retval = RfuProcessEnqueuedRecvBlock(); break; case 2: rfu_REQ_recvData_then_sendData(); @@ -1894,19 +1899,19 @@ bool32 sub_80FAE94(void) return retval; } -bool32 sub_80FAEF0(void) +bool32 LinkRfuMain2(void) { bool32 retval = FALSE; if (Rfu.unk_ef == 0) { - if (Rfu.unk_0c == 1) + if (Rfu.parent_child == MODE_PARENT) retval = sub_80F9204(); - sub_80FAD98(); + RfuCheckErrorStatus(); } return retval; } -static void sub_80FAF1C(void) +static void CopyPlayerNameToUnameBuffer(void) { StringCopy(gHostRFUtgtUnameBuffer, gSaveBlock2Ptr->playerName); } @@ -1914,94 +1919,96 @@ static void sub_80FAF1C(void) void ClearAndInitHostRFUtgtGname(void) { memset(&gHostRFUtgtGnameBuffer, 0, RFU_GAME_NAME_LENGTH); - InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, 0, 0, 0); + InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, 0, FALSE, 0); } -void SetHostRFUtgtGname(u8 a0, u32 a1, u32 a2) +void SetHostRFUtgtGname(u8 activity, u32 child_sprite_genders, u32 started) { - InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, a0, a2, a1); + InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, activity, started, child_sprite_genders); } -void sub_80FAF74(bool32 a0, bool32 a1) +void SetGnameBufferWonderFlags(bool32 hasNews, bool32 hasCard) { - gHostRFUtgtGnameBuffer.unk_00.unk_00_4 = a0; - gHostRFUtgtGnameBuffer.unk_00.unk_00_5 = a1; + gHostRFUtgtGnameBuffer.unk_00.hasNews = hasNews; + gHostRFUtgtGnameBuffer.unk_00.hasCard = hasCard; } -void sub_80FAFA0(u32 type, u32 species, u32 level) +void RfuUpdatePlayerGnameStateAndSend(u32 type, u32 species, u32 level) { gHostRFUtgtGnameBuffer.type = type; gHostRFUtgtGnameBuffer.species = species; gHostRFUtgtGnameBuffer.level = level; } -void sub_80FAFE0(u8 a0) +void UpdateGameData_GroupLockedIn(bool8 started) { - gHostRFUtgtGnameBuffer.unk_0a_7 = a0; - rfu_REQ_configGameData(0, 2, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); + gHostRFUtgtGnameBuffer.started = started; + rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); } -void sub_80FB008(u8 a0, u32 a1, u32 a2) +void UpdateGameDataWithActivitySpriteGendersFlag(u8 activity, u32 child_sprite_genders, u32 started) { - if (a0) - SetHostRFUtgtGname(a0, a1, a2); - rfu_REQ_configGameData(0, 2, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); + if (activity) + SetHostRFUtgtGname(activity, child_sprite_genders, started); + rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); } void sub_80FB030(u32 linkPlayerCount) { s32 i; - u32 r5; - u32 r7; - s32 r8; + u32 numConnectedChildren; + u32 child_sprite_genders; + s32 bm_child_slots; - if (sub_80F9800()->unk_0a_0 == 0x45) + if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { - r5 = 0; - r7 = 0; - r8 = Rfu.unk_ce2 ^ Rfu.unk_ce3; + numConnectedChildren = 0; + child_sprite_genders = 0; + bm_child_slots = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((r8 >> i) & 1) + if ((bm_child_slots >> i) & 1) { - r7 |= (( - 0x80 | ((gLinkPlayers[Rfu.unk_cde[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.unk_cde[i]].trainerId & 7)) << (r5 << 3)); - r5++; - if (r5 == linkPlayerCount - 1) + // The 0x80 prevents this element from being incorrectly read as a 0. + child_sprite_genders |= (( + 0x80 | ((gLinkPlayers[Rfu.linkPlayerIdx[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.linkPlayerIdx[i]].trainerId & 7) + ) << (numConnectedChildren << 3)); + numConnectedChildren++; + if (numConnectedChildren == linkPlayerCount - 1) break; } } - sub_80FB008(0x45, r7, 0); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, child_sprite_genders, 0); } } -static void sub_80FB0E8(u32 a0) +static void GetLinkmanErrorParams(u32 msg) { - if (Rfu.unk_ee == 0) + if (Rfu.errorState == 0) { - Rfu.unk_10 = gUnknown_3005E10.unk_14; - Rfu.unk_12 = gUnknown_3005E10.unk_16; - Rfu.unk_0a = a0; - Rfu.unk_ee = 1; + Rfu.linkman_param[0] = lman.param[0]; + Rfu.linkman_param[1] = lman.param[1]; + Rfu.linkman_msg = msg; + Rfu.errorState = 1; } } -static void sub_80FB118(void) +static void ResetErrorState(void) { - Rfu.unk_ee = 0; + Rfu.errorState = 0; } void sub_80FB128(bool32 a0) { if (!a0) - Rfu.unk_ee = 0; + Rfu.errorState = 0; else - Rfu.unk_ee = 4; + Rfu.errorState = 4; } static void sub_80FB154(void) { - sub_80FBE20(gUnknown_3005E10.unk_00, 1); + sub_80FBE20(lman.acceptSlot_flag, 1); Rfu.RfuFunc = NULL; } @@ -2010,25 +2017,25 @@ static void sub_80FB174(void) Rfu.RfuFunc = sub_80FB154; } -static void sub_80FB184(u8 a0, u8 unused1) +static void LmanCallback_Parent2(u8 msg, u8 param_count) { u8 i; - u8 r6 = 0; - switch (a0) + u8 bmDisconnectFlag = 0; + switch (msg) { - case 0x00: - Rfu.unk_04 = 2; + case LMAN_MSG_INITIALIZE_COMPLETED: + Rfu.state = 2; break; - case 0x10: + case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: break; - case 0x11: - sub_80FB564(gUnknown_3005E10.unk_14); + case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: + sub_80FB564(lman.param[0]); for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((gUnknown_3005E10.unk_14 >> i) & 1) + if ((lman.param[0] >> i) & 1) { struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; - if (structPtr->unk_0a_0 == sub_80F9800()->unk_0a_0) + if (structPtr->activity == GetHostRFUtgtGname()->activity) { Rfu.unk_cd1[i] = 0; Rfu.unk_cd5[i] = 0; @@ -2036,60 +2043,64 @@ static void sub_80FB184(u8 a0, u8 unused1) } else { - r6 |= (1 << i); + bmDisconnectFlag |= (1 << i); } } } - if (r6) + if (bmDisconnectFlag) { - rfu_REQ_disconnect(r6); + rfu_REQ_disconnect(bmDisconnectFlag); rfu_waitREQComplete(); } break; - case 0x12: + case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED: break; - case 0x13: + case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; - case 0x14: - if (Rfu.unk_ce7 != gUnknown_3005E10.unk_00) + case LMAN_MSG_END_WAIT_CHILD_NAME: + if (Rfu.acceptSlot_flag != lman.acceptSlot_flag) { - rfu_REQ_disconnect(Rfu.unk_ce7 ^ gUnknown_3005E10.unk_00); + rfu_REQ_disconnect(Rfu.acceptSlot_flag ^ lman.acceptSlot_flag); rfu_waitREQComplete(); } - Rfu.unk_04 = 0x11; + Rfu.state = 17; break; - case 0x31: - Rfu.unk_f0 = 1; + case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: + Rfu.linkLossRecoveryState = 1; break; - case 0x32: - Rfu.unk_f0 = 3; + case LMAN_MSG_LINK_RECOVERY_SUCCESSED: + Rfu.linkLossRecoveryState = 3; break; - case 0x30: - case 0x33: - Rfu.unk_f0 = 4; - Rfu.unk_ce2 &= ~gUnknown_3005E10.unk_14; + case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: + case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: + Rfu.linkLossRecoveryState = 4; + Rfu.bm_PartnerFlags &= ~lman.param[0]; if (gReceivedRemoteLinkPlayers == 1) { - if (Rfu.unk_ce2 == 0) - sub_80FB0E8(a0); + if (Rfu.bm_PartnerFlags == 0) + GetLinkmanErrorParams(msg); else sub_80FB174(); } - sub_80FB9E4(2, a0); + RfuSetErrorStatus(2, msg); break; case 0x34: break; - case 0x42 ... 0x44: + case LMAN_MSG_RFU_POWER_DOWN: + case LMAN_MSG_MANAGER_STOPPED: + case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; - case 0xf3: - sub_80FB9E4(1, a0); - sub_80FB0E8(a0); + case LMAN_MSG_LMAN_API_ERROR_RETURN: + RfuSetErrorStatus(1, msg); + GetLinkmanErrorParams(msg); Rfu.unk_ef = 1; break; - case 0xf0 ... 0xf2: - case 0xff: - sub_80FB0E8(a0); - sub_80FB9E4(1, a0); + case LMAN_MSG_REQ_API_ERROR: + case LMAN_MSG_WATCH_DOG_TIMER_ERROR: + case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: + case LMAN_MSG_RFU_FATAL_ERROR: + GetLinkmanErrorParams(msg); + RfuSetErrorStatus(1, msg); Rfu.unk_cdb = 1; break; } @@ -2097,80 +2108,84 @@ static void sub_80FB184(u8 a0, u8 unused1) static const u8 unref_843EDF3[] = _(" あきと"); -static void sub_80FB37C(u8 a0, u8 unused1) +static void LmanCallback_Child(u8 msg, u8 param_count) { - switch (a0) + switch (msg) { - case 0x00: - Rfu.unk_04 = 6; + case LMAN_MSG_INITIALIZE_COMPLETED: + Rfu.state = 6; break; - case 0x20: - Rfu.unk_ccd = gUnknown_3005E10.unk_14; + case LMAN_MSG_PARENT_FOUND: + Rfu.parentId = lman.param[0]; break; - case 0x21: + case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; - case 0x22: - Rfu.unk_c3e = gUnknown_3005E10.unk_14; + case LMAN_MSG_CONNECT_PARENT_SUCCESSED: + Rfu.child_slot = lman.param[0]; break; - case 0x23: - sub_80FB9E4(2, a0); + case LMAN_MSG_CONNECT_PARENT_FAILED: + RfuSetErrorStatus(2, msg); break; - case 0x24: - Rfu.unk_04 = 11; + case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: + Rfu.state = 11; Rfu.unk_c85 = 0; Rfu.unk_c86 = 0; - rfu_setRecvBuffer(TYPE_NI, Rfu.unk_c3e, &Rfu.unk_c86, 1); - rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, 70); + rfu_setRecvBuffer(TYPE_NI, Rfu.child_slot, &Rfu.unk_c86, 1); + rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); break; - case 0x25: - sub_80FB9E4(2, 0x25); + case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: + RfuSetErrorStatus(2, msg); break; - case 0x30: - Rfu.unk_f0 = 2; + case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: + Rfu.linkLossRecoveryState = 2; if (Rfu.unk_c86 == 6) break; - case 0x33: - if (Rfu.unk_f0 != 2) - Rfu.unk_f0 = 4; + case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: + if (Rfu.linkLossRecoveryState != 2) + Rfu.linkLossRecoveryState = 4; if (Rfu.unk_c86 != 9) - sub_80FB9E4(2, a0); - nullsub_87("LINK LOSS DISCONNECT!", 5, 5); + RfuSetErrorStatus(2, msg); + rfu_dbg_print_str("LINK LOSS DISCONNECT!", 5, 5); if (gReceivedRemoteLinkPlayers == 1) - sub_80FB0E8(a0); + GetLinkmanErrorParams(msg); break; - case 0x31: - Rfu.unk_f0 = 1; - nullsub_87("LINK LOSS RECOVERY NOW", 5, 5); + case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: + Rfu.linkLossRecoveryState = 1; + rfu_dbg_print_str("LINK LOSS RECOVERY NOW", 5, 5); break; - case 0x32: - Rfu.unk_f0 = 3; + case LMAN_MSG_LINK_RECOVERY_SUCCESSED: + Rfu.linkLossRecoveryState = 3; Rfu.unk_c3c = 1; break; case 0x34: break; - case 0x42 ... 0x44: + case LMAN_MSG_RFU_POWER_DOWN: + case LMAN_MSG_MANAGER_STOPPED: + case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; - case 0xF3: - sub_80FB9E4(1, a0); - sub_80FB0E8(a0); + case LMAN_MSG_LMAN_API_ERROR_RETURN: + RfuSetErrorStatus(1, msg); + GetLinkmanErrorParams(msg); Rfu.unk_ef = 1; break; - case 0xF0 ... 0xF2: - case 0xFF: - sub_80FB9E4(1, a0); - sub_80FB0E8(a0); + case LMAN_MSG_REQ_API_ERROR: + case LMAN_MSG_WATCH_DOG_TIMER_ERROR: + case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: + case LMAN_MSG_RFU_FATAL_ERROR: + RfuSetErrorStatus(1, msg); + GetLinkmanErrorParams(msg); Rfu.unk_cdb = 1; break; } } -static void sub_80FB564(s32 a0) +static void sub_80FB564(s32 bmConnectedFlag) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((a0 >> i) & 1) + if ((bmConnectedFlag >> i) & 1) { Rfu.unk_cea[i] = 0; Rfu.unk_cee[i] = 0xFF; @@ -2178,17 +2193,17 @@ static void sub_80FB564(s32 a0) } } -static u8 sub_80FB5A0(s32 a0) +static u8 GetNewChildrenInUnionRoomChat(s32 bmNewChildSlot) { u8 ret = 0; u8 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((a0 >> i) & 1) + if ((bmNewChildSlot >> i) & 1) { struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; - if (structPtr->unk_0a_0 == 0x45) + if (structPtr->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) ret |= (1 << i); } } @@ -2196,73 +2211,73 @@ static u8 sub_80FB5A0(s32 a0) return ret; } -static void sub_80FB5EC(u8 a0, u8 unused1) +static void LmanCallback_Parent(u8 msg, u8 param_count) { u8 r1; - switch (a0) + switch (msg) { - case 0x00: - Rfu.unk_04 = 0x11; + case LMAN_MSG_INITIALIZE_COMPLETED: + Rfu.state = 17; break; - case 0x10: - sub_80FB9E4(4, 0); + case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: + RfuSetErrorStatus(4, 0); break; - case 0x11: - if (sub_80F9800()->unk_0a_0 == 0x45 && Rfu.unk_cd9 == 0) + case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: + if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && Rfu.unk_cd9 == 0) { - u8 idx = sub_80FB5A0(gUnknown_3005E10.unk_14); - if (idx != 0) + u8 bmAcceptSlot = GetNewChildrenInUnionRoomChat(lman.param[0]); + if (bmAcceptSlot != 0) { - r1 = 1 << sub_80F886C(idx); - if (Rfu.unk_ce6 == 0 && !Rfu.unk_ce8) + r1 = 1 << sub_80F886C(bmAcceptSlot); + if (Rfu.unionRoomChatters == 0 && !Rfu.unk_ce8) { Rfu.unk_ce5 = r1; - Rfu.unk_ce6 |= (r1 ^ idx); + Rfu.unionRoomChatters |= (r1 ^ bmAcceptSlot); Rfu.unk_ce8 = TRUE; } else { - Rfu.unk_ce6 |= idx; + Rfu.unionRoomChatters |= bmAcceptSlot; } } - if (idx != gUnknown_3005E10.unk_14) + if (bmAcceptSlot != lman.param[0]) { - Rfu.unk_ce3 |= (idx ^ gUnknown_3005E10.unk_14); + Rfu.bm_DisconnectSlot |= (bmAcceptSlot ^ lman.param[0]); Rfu.unk_ce4 = 2; } } - else if (sub_80F9800()->unk_0a_0 == 0x54) + else if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM)) { - rfu_REQ_disconnect(gUnknown_3005E10.unk_00); + rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); } - sub_80FB564(gUnknown_3005E10.unk_14); + sub_80FB564(lman.param[0]); break; - case 0x12: + case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED: break; - case 0x13: + case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; - case 0x14: - if (sub_80F9800()->unk_0a_0 != 0x45 && gUnknown_3005E10.unk_01 > 1) + case LMAN_MSG_END_WAIT_CHILD_NAME: + if (GetHostRFUtgtGname()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1) { - r1 = 1 << sub_80F886C(gUnknown_3005E10.unk_14); - rfu_REQ_disconnect(gUnknown_3005E10.unk_00 ^ r1); + r1 = 1 << sub_80F886C(lman.param[0]); + rfu_REQ_disconnect(lman.acceptSlot_flag ^ r1); rfu_waitREQComplete(); } - if (Rfu.unk_04 == 0xF) - Rfu.unk_04 = 0x10; + if (Rfu.state == 0xF) + Rfu.state = 16; break; - case 0x20: - Rfu.unk_ccd = gUnknown_3005E10.unk_14; + case LMAN_MSG_PARENT_FOUND: + Rfu.parentId = lman.param[0]; break; - case 0x21: + case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; - case 0x22: - Rfu.unk_c3e = gUnknown_3005E10.unk_14; + case LMAN_MSG_CONNECT_PARENT_SUCCESSED: + Rfu.child_slot = lman.param[0]; break; - case 0x23: - Rfu.unk_04 = 0x12; + case LMAN_MSG_CONNECT_PARENT_FAILED: + Rfu.state = 18; if (Rfu.unk_ccf < 2) { Rfu.unk_ccf++; @@ -2270,67 +2285,72 @@ static void sub_80FB5EC(u8 a0, u8 unused1) } else { - sub_80FB9E4(2, a0); + RfuSetErrorStatus(2, msg); } break; - case 0x24: - Rfu.unk_04 = 0xD; - sub_80FB9E4(3, 0); - rfu_setRecvBuffer(TYPE_UNI, Rfu.unk_c3e, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); + case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: + Rfu.state = 13; + RfuSetErrorStatus(3, 0); + rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); break; - case 0x25: - sub_80FB9E4(2, a0); + case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: + RfuSetErrorStatus(2, msg); break; - case 0x31: - if (gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14) - Rfu.unk_f0 = 1; + case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: + if (lman.acceptSlot_flag & lman.param[0]) + Rfu.linkLossRecoveryState = 1; break; - case 0x32: - Rfu.unk_f0 = 3; + case LMAN_MSG_LINK_RECOVERY_SUCCESSED: + Rfu.linkLossRecoveryState = 3; if (gRfuLinkStatus->parentChild == MODE_CHILD) Rfu.unk_c3c = 1; break; - case 0x30: - Rfu.unk_f0 = 2; - case 0x33: - if (Rfu.unk_f0 != 2) - Rfu.unk_f0 = 4; - if (Rfu.unk_0c == 1) + case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: + Rfu.linkLossRecoveryState = 2; + // fallthrough + case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: + if (Rfu.linkLossRecoveryState != 2) + Rfu.linkLossRecoveryState = 4; + if (Rfu.parent_child == MODE_PARENT) { if (gReceivedRemoteLinkPlayers == 1) { - Rfu.unk_ce2 &= ~(gUnknown_3005E10.unk_14); - if (Rfu.unk_ce2 == 0) - sub_80FB0E8(a0); + Rfu.bm_PartnerFlags &= ~(lman.param[0]); + if (Rfu.bm_PartnerFlags == 0) + GetLinkmanErrorParams(msg); else sub_80FB174(); } } else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1) { - sub_80FB0E8(a0); - sub_80FD760(0); + GetLinkmanErrorParams(msg); + rfu_LMAN_stopManager(0); } - if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && gUnknown_3005E10.unk_07 == 0 && FuncIsActiveTask(sub_80F8B34) == TRUE) - Rfu.unk_04 = 0x11; + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && lman.pcswitch_flag == 0 && FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) + Rfu.state = 17; - sub_80FB9E4(2, a0); + RfuSetErrorStatus(2, msg); break; - case 0x40: - Rfu.unk_ce3 = 0; + case LMAN_MSG_LINK_DISCONNECTED_BY_USER: + Rfu.bm_DisconnectSlot = 0; break; - case 0x42 ... 0x44: + case LMAN_MSG_RFU_POWER_DOWN: + case LMAN_MSG_MANAGER_STOPPED: + case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; - case 0xF3: - sub_80FB9E4(1, a0); - sub_80FB0E8(a0); + case LMAN_MSG_LMAN_API_ERROR_RETURN: + RfuSetErrorStatus(1, msg); + GetLinkmanErrorParams(msg); Rfu.unk_ef = 1; break; - case 0xF0 ... 0xF2: - case 0xFF: - sub_80FB0E8(a0); - sub_80FB9E4(1, a0); + case LMAN_MSG_REQ_API_ERROR: + case LMAN_MSG_WATCH_DOG_TIMER_ERROR: + case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: + case LMAN_MSG_RFU_FATAL_ERROR: + GetLinkmanErrorParams(msg); + RfuSetErrorStatus(1, msg); Rfu.unk_cdb = 0; break; } @@ -2341,21 +2361,21 @@ void sub_80FB9D0(void) Rfu.unk_ce4 = 2; } -void sub_80FB9E4(u8 a0, u16 a1) +void RfuSetErrorStatus(u8 a0, u16 msg) { Rfu.unk_f1 = a0; - Rfu.unk_0a = a1; + Rfu.linkman_msg = msg; } -u8 sub_80FB9F4(void) +u8 RfuGetErrorStatus(void) { return Rfu.unk_f1; } -bool32 sub_80FBA00(void) +bool32 RfuIsErrorStatus1or2(void) { - u32 var = sub_80FB9F4() - 1; - if (var < 2) + u32 var = RfuGetErrorStatus(); + if (var == 1 || var == 2) return TRUE; else return FALSE; @@ -2368,12 +2388,12 @@ bool32 GetRfuUnkCE8(void) bool8 Rfu_IsMaster(void) { - return Rfu.unk_0c; + return Rfu.parent_child; } void RFUVSync(void) { - LinkRfu_syncVBlank_(); + rfu_LMAN_syncVBlank(); } void sub_80FBA44(void) @@ -2400,7 +2420,7 @@ static void sub_80FBA78(void) if (IsWirelessAdapterConnected()) { gLinkType = LINKTYPE_0x1111; - sub_800B1F4(); + SetWirelessCommType1(); OpenLink(); SeedRng(gMain.vblankCounter2); for (i = 0; i < RFU_CHILD_MAX; i++) @@ -2411,25 +2431,25 @@ static void sub_80FBA78(void) AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); - sub_80FBB20(); + LinkRfu_CreateIdleTask(); SetMainCallback2(sub_80FBB74); } } -bool32 sub_80FBB0C(void) +bool32 IsUnionRoomListenTaskActive(void) { - return FuncIsActiveTask(sub_80F8B34); + return FuncIsActiveTask(Task_LinkRfu_UnionRoomListen); } -void sub_80FBB20(void) +void LinkRfu_CreateIdleTask(void) { - if (!FuncIsActiveTask(nullsub_89)) - Rfu.unk_66 = CreateTask(nullsub_89, 0); + if (!FuncIsActiveTask(Task_idle)) + Rfu.unk_66 = CreateTask(Task_idle, 0); } -void sub_80FBB4C(void) +void LinkRfu_DestroyIdleTask(void) { - if (FuncIsActiveTask(nullsub_89) == TRUE) + if (FuncIsActiveTask(Task_idle) == TRUE) DestroyTask(Rfu.unk_66); } @@ -2441,35 +2461,35 @@ static void sub_80FBB74(void) UpdatePaletteFade(); } -void sub_80FBB8C(u32 a0) +void InitializeRfuLinkManager_LinkLeader(u32 availSlots) { - Rfu.unk_0c = 1; - sub_80FAF1C(); - sub_80FD430(sub_80FB184, NULL); + Rfu.parent_child = MODE_PARENT; + CopyPlayerNameToUnameBuffer(); + rfu_LMAN_initializeManager(LmanCallback_Parent2, NULL); sRfuReqConfig = sRfuReqConfigTemplate; - sRfuReqConfig.availSlotFlag = sAvailSlots[a0 - 1]; - sub_80F8E74(); + sRfuReqConfig.availSlot_flag = sAvailSlots[availSlots - 1]; + CreateTask_LinkLeaderSearchForChildren(); } -void sub_80FBBD8(void) +void InitializeRfuLinkManager_JoinGroup(void) { - Rfu.unk_0c = 0; - sub_80FAF1C(); - sub_80FD430(sub_80FB37C, sub_80F8D20); - sub_80F8F10(); + Rfu.parent_child = MODE_CHILD; + CopyPlayerNameToUnameBuffer(); + rfu_LMAN_initializeManager(LmanCallback_Child, MscCallback_Child); + CreateTask_JoinGroupSearchForParent(); } -void sub_80FBC00(void) +void InitializeRfuLinkManager_EnterUnionRoom(void) { if (gQuestLogState == 2 || gQuestLogState == 3) return; - Rfu.unk_0c = 2; - sub_80FAF1C(); - sub_80FD430(sub_80FB5EC, NULL); + Rfu.parent_child = 2; + CopyPlayerNameToUnameBuffer(); + rfu_LMAN_initializeManager(LmanCallback_Parent, NULL); sRfuReqConfig = sRfuReqConfigTemplate; - sRfuReqConfig.unk_11 = 0; - sRfuReqConfig.unk_12 = 0x258; - Rfu.unk_67 = CreateTask(sub_80F8B34, 1); + sRfuReqConfig.linkRecovery_enable = 0; + sRfuReqConfig.linkRecovery_period = 600; + Rfu.unk_67 = CreateTask(Task_LinkRfu_UnionRoomListen, 1); } static u16 ReadU16(const void *ptr) @@ -2478,17 +2498,24 @@ static u16 ReadU16(const void *ptr) return (ptr_[1] << 8) | (ptr_[0]); } -static u8 sub_80FBC70(const u8 *a0, u16 a1) +/* + * ================================================================ + * Looks up the player by uname and pid. Returns the index in + * gRfuLinkStatus->partner of the first match with a valid slot ID. + * Returns 0xFF if not found. + * ================================================================ + */ +static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId) { u8 i; u8 ret = 0xFF; for (i = 0; i < RFU_CHILD_MAX; i++) { - u16 trainerId = ReadU16(((struct GFtgtGname *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId); - if (sub_80FA44C(gRfuLinkStatus->partner[i].serialNo) - && !StringCompare(a0, gRfuLinkStatus->partner[i].uname) - && a1 == trainerId) + u16 partnerTrainerId = ReadU16(((struct GFtgtGname *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId); + if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[i].serialNo) + && !StringCompare(trainerName, gRfuLinkStatus->partner[i].uname) + && trainerId == partnerTrainerId) { ret = i; if (gRfuLinkStatus->partner[i].slot != 0xFF) @@ -2499,21 +2526,21 @@ static u8 sub_80FBC70(const u8 *a0, u16 a1) return ret; } -static void sub_80FBCF8(u32 a0) +static void RfuReqDisconnectSlot(u32 bmDisconnectSlot) { - rfu_REQ_disconnect(a0); + rfu_REQ_disconnect(bmDisconnectSlot); rfu_waitREQComplete(); - Rfu.unk_ce2 &= ~(a0); + Rfu.bm_PartnerFlags &= ~(bmDisconnectSlot); rfu_clearSlot(TYPE_UNI_SEND, Rfu.unk_cda); - rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, 70); - Rfu.unk_cda = sub_80F886C(Rfu.unk_ce2); + rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, 70); + Rfu.unk_cda = sub_80F886C(Rfu.bm_PartnerFlags); } -void sub_80FBD4C(const u8 *ptr, u16 a1) +void RequestDisconnectSlotByTrainerNameAndId(const u8 *trainerName, u16 trainerId) { - u8 var = sub_80FBC70(ptr, a1); + u8 var = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (var != 0xFF) - sub_80FBCF8(1 << var); + RfuReqDisconnectSlot(1 << var); } void sub_80FBD6C(u32 a0) @@ -2525,7 +2552,7 @@ void sub_80FBD6C(u32 a0) for (i = 0; i < RFU_CHILD_MAX; i++) { - if (Rfu.unk_cde[i] == a0 && (Rfu.unk_ce2 >> i) & 1) + if (Rfu.linkPlayerIdx[i] == a0 && (Rfu.bm_PartnerFlags >> i) & 1) var |= 1 << i; } if (var) @@ -2537,7 +2564,7 @@ static void sub_80FBDB8(u8 taskId) { if (gSendCmd[0] == 0 && !Rfu.unk_ce8) { - sub_80F9D04(0xED00); + RfuPrepareSendBuffer(RFU_COMMAND_0xed00); gSendCmd[1] = gTasks[taskId].data[0]; gSendCmd[2] = gTasks[taskId].data[1]; Rfu.playerCount -= gUnknown_843EC41[gTasks[taskId].data[0]]; @@ -2562,35 +2589,35 @@ static void sub_80FBE20(u32 a0, u32 a1) gTasks[taskId].data[1] = a1; } -static void sub_80FBE80(u8 taskId) +static void Task_RfuReconnectWithParent(u8 taskId) { s16 *data = gTasks[taskId].data; - if (sub_80F8EA4()) + if (RfuStateIs7AndPlayerIsChild()) { - u8 id = sub_80FBC70((u8*)data, ReadU16(&data[8])); + u8 id = GetPartnerIndexByNameAndTrainerID((u8*)data, ReadU16(&data[8])); if (id != 0xFF) { if (gRfuLinkStatus->partner[id].slot != 0xFF) { - Rfu.unk_c3d = id; - if (sub_80F8ECC()) + Rfu.reconnectedParentIdx = id; + if (IsParentSuccessfullyReconnected()) DestroyTask(taskId); } - else if (sub_80F9800()->unk_0a_0 == 0x15 || sub_80F9800()->unk_0a_0 == 0x16) + else if (GetHostRFUtgtGname()->activity == ACTIVITY_WCARD2 || GetHostRFUtgtGname()->activity == ACTIVITY_WNEWS2) { data[15]++; } else { - sub_80FB9E4(2, 0x7000); + RfuSetErrorStatus(2, 0x7000); DestroyTask(taskId); } } else { data[15]++; - Rfu.unk_c3d = id; + Rfu.reconnectedParentIdx = id; } } else @@ -2600,47 +2627,47 @@ static void sub_80FBE80(u8 taskId) if (data[15] > 240) { - sub_80FB9E4(2, 0x7000); + RfuSetErrorStatus(2, 0x7000); DestroyTask(taskId); } } -void sub_80FBF54(const u8 *src, u16 trainerId) +void CreateTask_RfuReconnectWithParent(const u8 *trainerName, u16 trainerId) { u8 taskId; s16 *data; Rfu.unk_f1 = 0; - taskId = CreateTask(sub_80FBE80, 3); + taskId = CreateTask(Task_RfuReconnectWithParent, 3); data = gTasks[taskId].data; - StringCopy((u8*)(data), src); + StringCopy((u8*)(data), trainerName); data[8] = trainerId; } -static bool32 sub_80FBF98(s16 a1, struct GFtgtGname *structPtr) +static bool32 ShouldRejectPartnerConnectionBasedOnActivity(s16 activity, struct GFtgtGname *partnerGname) { - if (sub_80F9800()->unk_0a_0 == 0x45) + if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { - if (structPtr->unk_0a_0 != 0x45) + if (partnerGname->activity != (ACTIVITY_CHAT | IN_UNION_ROOM)) return TRUE; } - else if (structPtr->unk_0a_0 != 0x40) + else if (partnerGname->activity != IN_UNION_ROOM) { return TRUE; } - else if (a1 == 0x44) + else if (activity == (ACTIVITY_TRADE | IN_UNION_ROOM)) { - struct GFtgtGname *structPtr2 = (struct GFtgtGname *)&Rfu.unk_104.gname; - if (structPtr2->species == SPECIES_EGG) + struct GFtgtGname *myTradeGname = (struct GFtgtGname *)&Rfu.unk_104.gname; + if (myTradeGname->species == SPECIES_EGG) { - if (structPtr->species == structPtr2->species) + if (partnerGname->species == myTradeGname->species) return FALSE; else return TRUE; } - else if (structPtr->species != structPtr2->species - || structPtr->level != structPtr2->level - || structPtr->type != structPtr2->type) + else if (partnerGname->species != myTradeGname->species + || partnerGname->level != myTradeGname->level + || partnerGname->type != myTradeGname->type) { return TRUE; } @@ -2656,34 +2683,34 @@ static void sub_80FC028(u8 taskId) if (++gTasks[taskId].data[0] > 300) { - sub_80FB9E4(2, 0x7000); + RfuSetErrorStatus(2, 0x7000); DestroyTask(taskId); } - if (Rfu.unk_ccd != 0 && gUnknown_3005E10.unk_06 == 0) + if (Rfu.parentId != 0 && lman.parent_child == MODE_CHILD) { u16 trainerId = ReadU16(((struct GFtgtGname *)&Rfu.unk_104.gname)->unk_00.playerTrainerId); - u8 id = sub_80FBC70(Rfu.unk_104.uname, trainerId); + u8 id = GetPartnerIndexByNameAndTrainerID(Rfu.unk_104.uname, trainerId); if (id != 0xFF) { - if (!sub_80FBF98(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname)) + if (!ShouldRejectPartnerConnectionBasedOnActivity(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname)) { - if (gRfuLinkStatus->partner[id].slot != 0xFF && !sub_80FD610(gRfuLinkStatus->partner[id].id, 0x5A)) + if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 90)) { - Rfu.unk_04 = 0xA; + Rfu.state = 10; DestroyTask(taskId); } } else { - sub_80FB9E4(2, 0x7000); + RfuSetErrorStatus(2, 0x7000); DestroyTask(taskId); } } } } -void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2) +void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 activity) { u8 taskId, taskId2; @@ -2691,11 +2718,11 @@ void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2) Rfu.unk_f1 = 0; StringCopy(Rfu.unk_104.uname, name); memcpy(Rfu.unk_104.gname, structPtr, RFU_GAME_NAME_LENGTH); - sub_80FEB3C(); + rfu_LMAN_forceChangeSP(); taskId = CreateTask(sub_80FC028, 2); - gTasks[taskId].data[1] = a2; - taskId2 = FindTaskIdByFunc(sub_80F8B34); - if (a2 == 0x45) + gTasks[taskId].data[1] = activity; + taskId2 = FindTaskIdByFunc(Task_LinkRfu_UnionRoomListen); + if (activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { if (taskId2 != 0xFF) gTasks[taskId2].data[7] = 1; @@ -2709,7 +2736,7 @@ void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2) bool8 sub_80FC1B0(void) { - if (Rfu.unk_f0 == 1) + if (Rfu.linkLossRecoveryState == 1) return TRUE; else return FALSE; @@ -2721,19 +2748,19 @@ bool32 sub_80FC1CC(void) for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((gUnknown_3005E10.unk_00 >> i) & 1 && Rfu.unk_cd1[i] == 0) + if ((lman.acceptSlot_flag >> i) & 1 && Rfu.unk_cd1[i] == 0) return FALSE; } return TRUE; } -static void sub_80FC208(void) +static void rfu_dbg_clear(void) { s32 i; for (i = 0; i < 20; i++) - nullsub_87(" ", 0, i); + rfu_dbg_print_str(" ", 0, i); } static const char gUnknown_843EE47[16] = { @@ -2749,44 +2776,44 @@ static const char gUnknown_843EE57[9] = { static const char gUnknown_843EE60[] = {' ', '\0'}; static const char gUnknown_843EE62[] = {'*', '\0'}; -static void sub_80FC228(void) +static void rfu_dbg_print_status(void) { s32 i, j; - nullsub_88(GetBlockReceivedStatus(), 0x1C, 0x13, 2); - nullsub_88(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1); - nullsub_88(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1); - if (Rfu.unk_0c == 1) + rfu_dbg_print_num(GetBlockReceivedStatus(), 0x1C, 0x13, 2); + rfu_dbg_print_num(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1); + rfu_dbg_print_num(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1); + if (Rfu.parent_child == MODE_PARENT) { for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gRfuLinkStatus->getNameFlag >> i) & 1) { - nullsub_88(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); - nullsub_87((void*) &gRfuLinkStatus->partner[i].gname, 6, i + 3); - nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); + rfu_dbg_print_num(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); + rfu_dbg_print_str((void*) &gRfuLinkStatus->partner[i].gname, 6, i + 3); + rfu_dbg_print_str(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } for (i = 0; i < RFU_CHILD_MAX; i++) { for (j = 0; j < 14; j++) { - nullsub_88(Rfu.unk_14[i][j], j * 2, i + 11, 2); + rfu_dbg_print_num(Rfu.unk_14[i][j], j * 2, i + 11, 2); } } - nullsub_87("NOWSLOT", 1, 0xF); + rfu_dbg_print_str("NOWSLOT", 1, 0xF); } else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0) { for (i = 0; i < RFU_CHILD_MAX; i++) { - nullsub_88(0, 1, i + 3, 4); - nullsub_87(gUnknown_843EE47, 6, i + 3); - nullsub_87(gUnknown_843EE57, 0x16, i + 3); + rfu_dbg_print_num(0, 1, i + 3, 4); + rfu_dbg_print_str(gUnknown_843EE47, 6, i + 3); + rfu_dbg_print_str(gUnknown_843EE57, 0x16, i + 3); } - nullsub_88(gRfuLinkStatus->partner[Rfu.unk_c3e].serialNo, 1, 3, 4); - nullsub_87(gRfuLinkStatus->partner[Rfu.unk_c3e].gname, 6, 3); - nullsub_87(gRfuLinkStatus->partner[Rfu.unk_c3e].uname, 0x16, 3); + rfu_dbg_print_num(gRfuLinkStatus->partner[Rfu.child_slot].serialNo, 1, 3, 4); + rfu_dbg_print_str(gRfuLinkStatus->partner[Rfu.child_slot].gname, 6, 3); + rfu_dbg_print_str(gRfuLinkStatus->partner[Rfu.child_slot].uname, 0x16, 3); } else { @@ -2794,16 +2821,16 @@ static void sub_80FC228(void) { if (gRfuLinkStatus->partner[i].slot != 0xFF) { - nullsub_88(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); - nullsub_88(gRfuLinkStatus->partner[i].id, 6, i + 3, 4); - nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); + rfu_dbg_print_num(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); + rfu_dbg_print_num(gRfuLinkStatus->partner[i].id, 6, i + 3, 4); + rfu_dbg_print_str(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } for (; i < RFU_CHILD_MAX; i++) { - nullsub_88(0, 1, i + 3, 4); - nullsub_87(gUnknown_843EE47, 6, i + 3); - nullsub_87(gUnknown_843EE57, 0x16, i + 3); + rfu_dbg_print_num(0, 1, i + 3, 4); + rfu_dbg_print_str(gUnknown_843EE47, 6, i + 3); + rfu_dbg_print_str(gUnknown_843EE57, 0x16, i + 3); } } } @@ -2824,15 +2851,15 @@ static const char gUnknown_843EEA8[][8] = { static u32 sub_80FC44C(void) { - return Rfu.unk_9e8.unk_232; + return Rfu.unk_9e8.count; } u32 GetRfuRecvQueueLength(void) { - return Rfu.unk_124.unk_8c2; + return Rfu.unk_124.count; } -static void nullsub_89(u8 taskId) +static void Task_idle(u8 taskId) { } diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c index 69b6603a8..d3f6e93db 100644 --- a/src/link_rfu_3.c +++ b/src/link_rfu_3.c @@ -166,7 +166,7 @@ static const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = { SpriteCallbackDummy }; -void sub_80FC478(struct UnkRfuStruct_2_Sub_124 *ptr) +void RFU_queue_20_70_reset(struct UnkRfuStruct_2_Sub_124 *queue) { s32 i; s32 j; @@ -175,16 +175,16 @@ void sub_80FC478(struct UnkRfuStruct_2_Sub_124 *ptr) { for (j = 0; j < 70; j++) { - ptr->unk_00[i][j] = 0; + queue->slots[i][j] = 0; } } - ptr->unk_8c1 = 0; - ptr->unk_8c0 = 0; - ptr->unk_8c2 = 0; - ptr->unk_8c3 = 0; + queue->send_slot = 0; + queue->recv_slot = 0; + queue->count = 0; + queue->full = 0; } -void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr) +void RFU_queue_40_14_reset(struct UnkRfuStruct_2_Sub_9e8 *ptr) { s32 i; s32 j; @@ -193,16 +193,16 @@ void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr) { for (j = 0; j < 14; j++) { - ptr->unk_00[i][j] = 0; + ptr->slots[i][j] = 0; } } - ptr->unk_231 = 0; - ptr->unk_230 = 0; - ptr->unk_232 = 0; - ptr->unk_233 = 0; + ptr->send_slot = 0; + ptr->recv_slot = 0; + ptr->count = 0; + ptr->full = 0; } -static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr) +static void RFU_queue_2_256_reset(struct UnkRfuStruct_Sub_Unused *ptr) { s32 i; s32 j; @@ -211,29 +211,29 @@ static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr) { for (j = 0; j < 256; j++) { - ptr->unk_00[i][j] = 0; + ptr->slots[i][j] = 0; } } - ptr->unk_201 = 0; - ptr->unk_200 = 0; - ptr->unk_202 = 0; - ptr->unk_203 = 0; + ptr->send_slot = 0; + ptr->recv_slot = 0; + ptr->count = 0; + ptr->full = 0; } -void sub_80FC588(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2) +void RFU_queue_20_70_recv(struct UnkRfuStruct_2_Sub_124 *queue, u8 *data) { s32 i; u16 imeBak; u8 count; - if (q1->unk_8c2 < 20) + if (queue->count < 20) { imeBak = REG_IME; REG_IME = 0; count = 0; for (i = 0; i < 70; i += 14) { - if (q2[i] == 0 && q2[i + 1] == 0) + if (data[i] == 0 && data[i + 1] == 0) { count++; } @@ -242,36 +242,36 @@ void sub_80FC588(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2) { for (i = 0; i < 70; i++) { - q1->unk_00[q1->unk_8c0][i] = q2[i]; + queue->slots[queue->recv_slot][i] = data[i]; } - q1->unk_8c0++; - q1->unk_8c0 %= 20; - q1->unk_8c2++; + queue->recv_slot++; + queue->recv_slot %= 20; + queue->count++; for (i = 0; i < 70; i++) { - q2[i] = 0; + data[i] = 0; } } REG_IME = imeBak; } else { - q1->unk_8c3 = 1; + queue->full = 1; } } -void sub_80FC63C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) +void RFU_queue_40_14_recv(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *data) { s32 i; u16 imeBak; - if (q1->unk_232 < 40) + if (queue->count < 40) { imeBak = REG_IME; REG_IME = 0; for (i = 0; i < 14; i++) { - if (q2[i] != 0) + if (data[i] != 0) { break; } @@ -280,57 +280,57 @@ void sub_80FC63C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) { for (i = 0; i < 14; i++) { - q1->unk_00[q1->unk_230][i] = q2[i]; + queue->slots[queue->recv_slot][i] = data[i]; } - q1->unk_230++; - q1->unk_230 %= 40; - q1->unk_232++; + queue->recv_slot++; + queue->recv_slot %= 40; + queue->count++; for (i = 0; i < 14; i++) { - q2[i] = 0; + data[i] = 0; } } REG_IME = imeBak; } else { - q1->unk_233 = 1; + queue->full = 1; } } -bool8 sub_80FC6E8(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2) +bool8 RFU_queue_20_70_send(struct UnkRfuStruct_2_Sub_124 *queue, u8 *dest) { u16 imeBak; s32 i; imeBak = REG_IME; REG_IME = 0; - if (q1->unk_8c0 == q1->unk_8c1 || q1->unk_8c3 != 0) + if (queue->recv_slot == queue->send_slot || queue->full) { for (i = 0; i < 70; i++) { - q2[i] = 0; + dest[i] = 0; } REG_IME = imeBak; return FALSE; } for (i = 0; i < 70; i++) { - q2[i] = q1->unk_00[q1->unk_8c1][i]; + dest[i] = queue->slots[queue->send_slot][i]; } - q1->unk_8c1++; - q1->unk_8c1 %= 20; - q1->unk_8c2--; + queue->send_slot++; + queue->send_slot %= 20; + queue->count--; REG_IME = imeBak; return TRUE; } -bool8 sub_80FC79C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) +bool8 RFU_queue_40_14_send(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *dest) { s32 i; u16 imeBak; - if (q1->unk_230 == q1->unk_231 || q1->unk_233 != 0) + if (queue->recv_slot == queue->send_slot || queue->full != 0) { return FALSE; } @@ -338,98 +338,98 @@ bool8 sub_80FC79C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) REG_IME = 0; for (i = 0; i < 14; i++) { - q2[i] = q1->unk_00[q1->unk_231][i]; + dest[i] = queue->slots[queue->send_slot][i]; } - q1->unk_231++; - q1->unk_231 %= 40; - q1->unk_232--; + queue->send_slot++; + queue->send_slot %= 40; + queue->count--; REG_IME = imeBak; return TRUE; } -void sub_80FC828(struct UnkRfuStruct_2_Sub_c1c *q1, const u8 *q2) +void RFU_queue_2_14_recv(struct UnkRfuStruct_2_Sub_c1c *queue, const u8 *data) { s32 i; - if (q2[1] == 0) + if (data[1] == 0) { - sub_80FC888(q1, NULL); + RFU_queue_2_14_send(queue, NULL); } else { for (i = 0; i < 14; i++) { - q1->unk_00[q1->unk_1c][i] = q2[i]; + queue->slots[queue->recv_slot][i] = data[i]; } - q1->unk_1c++; - q1->unk_1c %= 2; - if (q1->unk_1e < 2) + queue->recv_slot++; + queue->recv_slot %= 2; + if (queue->count < 2) { - q1->unk_1e++; + queue->count++; } else { - q1->unk_1d = q1->unk_1c; + queue->send_slot = queue->recv_slot; } } } -bool8 sub_80FC888(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2) +bool8 RFU_queue_2_14_send(struct UnkRfuStruct_2_Sub_c1c *queue, u8 *dest) { s32 i; - if (q1->unk_1e == 0) + if (queue->count == 0) { return FALSE; } - if (q2 != NULL) + if (dest != NULL) { for (i = 0; i < 14; i++) { - q2[i] = q1->unk_00[q1->unk_1d][i]; + dest[i] = queue->slots[queue->send_slot][i]; } } - q1->unk_1d++; - q1->unk_1d %= 2; - q1->unk_1e--; + queue->send_slot++; + queue->send_slot %= 2; + queue->count--; return TRUE; } -static void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +static void RFU_queue_2_256_recv(struct UnkRfuStruct_Sub_Unused *queue, u8 *data) { s32 i; - if (q1->unk_202 < 2) + if (queue->count < 2) { for (i = 0; i < 256; i++) { - q1->unk_00[q1->unk_200][i] = q2[i]; + queue->slots[queue->recv_slot][i] = data[i]; } - q1->unk_200++; - q1->unk_200 %= 2; - q1->unk_202++; + queue->recv_slot++; + queue->recv_slot %= 2; + queue->count++; } else { - q1->unk_203 = 1; + queue->full = 1; } } -static bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +static bool8 RFU_queue_2_256_send(struct UnkRfuStruct_Sub_Unused *queue, u8 *send) { s32 i; - if (q1->unk_200 == q1->unk_201 || q1->unk_203) + if (queue->recv_slot == queue->send_slot || queue->full) { return FALSE; } for (i = 0; i < 256; i++) { - q2[i] = q1->unk_00[q1->unk_201][i]; + send[i] = queue->slots[queue->send_slot][i]; } - q1->unk_201++; - q1->unk_201 %= 2; - q1->unk_202--; + queue->send_slot++; + queue->send_slot %= 2; + queue->count--; return TRUE; } @@ -438,7 +438,7 @@ static void sub_80FC9B8(u8 *q1, u8 mode) s32 i; u8 rval; u16 r5 = 0; - static u8 _3002018; + static u8 counter; switch (mode) { @@ -470,11 +470,11 @@ static void sub_80FC9B8(u8 *q1, u8 mode) case 3: for (i = 0; i < 200; i++) { - q1[i] = i + 1 + _3002018; - r5 += (i + 1 + _3002018) & 0xFF; + q1[i] = i + 1 + counter; + r5 += (i + 1 + counter) & 0xFF; } *((u16 *)(q1 + i)) = r5; - _3002018++; + counter++; break; } } @@ -603,7 +603,7 @@ static u8 GetConnectedChildStrength(u8 maxFlags) } #endif -void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 r2, s32 r3) +void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 started, s32 child_sprite_genders) { s32 i; @@ -613,30 +613,37 @@ void InitHostRFUtgtGname(struct GFtgtGname *data, u8 activity, bool32 r2, s32 r3 } for (i = 0; i < RFU_CHILD_MAX; i++) { - data->unk_04[i] = r3; - r3 >>= 8; + data->child_sprite_gender[i] = child_sprite_genders; + child_sprite_genders >>= 8; } data->playerGender = gSaveBlock2Ptr->playerGender; - data->unk_0a_0 = activity; - data->unk_0a_7 = r2; - data->unk_00.unk_00_0 = GAME_LANGUAGE; - data->unk_00.unk_01_2 = GAME_VERSION; - data->unk_00.unk_00_4 = 0; - data->unk_00.unk_00_5 = 0; + data->activity = activity; + data->started = started; + data->unk_00.language = GAME_LANGUAGE; + data->unk_00.version = GAME_VERSION; + data->unk_00.hasNews = FALSE; + data->unk_00.hasCard = FALSE; data->unk_00.unk_00_6 = 0; data->unk_00.isChampion = FlagGet(FLAG_SYS_CAN_LINK_WITH_RS); data->unk_00.hasNationalDex = IsNationalPokedexEnabled(); data->unk_00.gameClear = FlagGet(FLAG_SYS_GAME_CLEAR); } -bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx) +/* + * ========================================================== + * Returns 1 if parent, 0 if child or neutral. + * If partner serial number is valid, copies gname and uname. + * Otherwise, blanks these. + * ========================================================== + */ +bool8 LinkRfu_GetNameIfCompatible(struct GFtgtGname *gname, u8 *uname, u8 idx) { bool8 retVal; - if (gUnknown_3005E10.unk_06 == 1) + if (lman.parent_child == MODE_PARENT) { retVal = TRUE; - if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1)) + if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1)) { memcpy(gname, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); memcpy(uname, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); @@ -650,7 +657,7 @@ bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx) else { retVal = FALSE; - if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo)) + if (RfuSerialNumberIsValid(gRfuLinkStatus->partner[idx].serialNo)) { memcpy(gname, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); memcpy(uname, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); @@ -664,7 +671,13 @@ bool8 sub_80FCC3C(struct GFtgtGname *gname, u8 *uname, u8 idx) return retVal; } -bool8 sub_80FCCF4(struct GFtgtGname *gname, u8 *uname, u8 idx) +/* + * ========================================================== + * Specific check for serial number 0x7F7D, + * which comes from ??? + * ========================================================== + */ +bool8 LinkRfu_GetNameIfSerial7F7D(struct GFtgtGname *gname, u8 *uname, u8 idx) { bool8 retVal = FALSE; if (gRfuLinkStatus->partner[idx].serialNo == 0x7F7D) @@ -824,7 +837,7 @@ void UpdateWirelessStatusIndicatorSprite(void) gMain.oamBuffer[125].paletteNum = sprite->oam.paletteNum; gMain.oamBuffer[125].tileNum = sprite->data[6] + sprite->anims[sprite->data[2]][sprite->data[4]].frame.imageValue; CpuCopy16(gMain.oamBuffer + 125, (struct OamData *)OAM + 125, sizeof(struct OamData)); - if (sub_80FB9F4() == 1) + if (RfuGetErrorStatus() == 1) { DestroyWirelessStatusIndicatorSprite(); } diff --git a/src/list_menu.c b/src/list_menu.c index 6c4d50961..706c1679b 100644 --- a/src/list_menu.c +++ b/src/list_menu.c @@ -763,7 +763,7 @@ void sub_8107CF8(u8 windowId, u16 speciesId, u32 personality, u16 x, u16 y) BlitBitmapToWindow(windowId, GetMonIconPtr(speciesId, personality, 1), x, y, 32, 32); } -void sub_8107D38(u8 palOffset, u8 palId) +void ListMenuLoadStdPalAt(u8 palOffset, u8 palId) { const u16 *palette; diff --git a/src/mevent.c b/src/mevent.c index afad326b5..a246e3e44 100644 --- a/src/mevent.c +++ b/src/mevent.c @@ -9,7 +9,7 @@ #include "decompress.h" #include "link.h" #include "link_rfu.h" -#include "unk_815c27c.h" +#include "ereader_helpers.h" #include "util.h" #include "script.h" #include "event_data.h" @@ -21,77 +21,65 @@ #include "mystery_gift_menu.h" #include "help_system.h" #include "mevent.h" +#include "strings.h" struct MEventTaskData1 { - u16 t00; + u16 stateAdvanceDelay; u16 t02; u16 t04; u16 t06; u8 state; - u8 t09; + u8 textOrReceiveState; u8 t0A; u8 t0B; u8 t0C; u8 t0D; - u8 t0E; + u8 initialSendResult; struct MEvent_Str_2 *t10; }; -void sub_8143910(u8 taskId); -bool32 sub_8143E64(const struct MEWonderNewsData * src); -void sub_8143E9C(void); -void sub_8143ED0(void); -bool32 sub_8144018(const struct MEWonderCardData * src); -void BlankSavedWonderCard(void); -void BlankMEventBuffer2(void); -void sub_8144824(u32, u32, u32 *, s32); -void sub_8144790(void); - -extern const u8 gUnknown_841DE52[]; -extern const u8 gUnknown_841DE53[]; -extern const u8 gUnknown_841DE54[]; -extern const u8 gUnknown_841DE7C[]; -extern const u8 gUnknown_841DE7D[]; -extern const u8 gUnknown_841DE95[]; -extern const u8 gUnknown_841DE96[]; -extern const u8 gUnknown_841DE97[]; -extern const u8 gUnknown_841DE98[]; -extern const u8 gUnknown_841DE99[]; -extern const u8 gUnknown_841DE9A[]; -extern const u8 gUnknown_841DE9B[]; -extern const u8 gUnknown_841DE9C[]; +static void Task_EReaderComm(u8 taskId); +static bool32 IsReceivedWonderNewsHeaderValid(const struct MEWonderNewsData * src); +static void BlankWonderNews(void); +static void BlankMENewsJisan(void); +static bool32 IsReceivedWonderCardHeaderValid(const struct MEWonderCardData * src); +static void BlankSavedWonderCard(void); +static void BlankMEventBuffer2(void); +static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 *idsList, s32 count); +static void BlankBuffer344(void); + extern const u8 gUnknownSerialData_Start[]; extern const u8 gUnknownSerialData_End[]; -const u16 gUnknown_8466F00[] = { - 0x02a7, - 0x02a8, - 0x02a9, - 0x02aa, - 0x02ab, - 0x02ac, - 0x02ad, - 0x02ae, - 0x02af, - 0x02b0, - 0x02b1, - 0x02b2, - 0x02b3, - 0x02b4, - 0x02b5, - 0x02b6, - 0x02b7, - 0x02b8, - 0x02b9, - 0x02ba +static const u16 sGiftItemFlagIds[] = { + FLAG_GOT_AURORA_TICKET, + FLAG_GOT_MYSTIC_TICKET, + FLAG_0x2A9, + FLAG_0x2AA, + FLAG_0x2AB, + FLAG_0x2AC, + FLAG_0x2AD, + FLAG_0x2AE, + FLAG_0x2AF, + FLAG_0x2B0, + FLAG_0x2B1, + FLAG_0x2B2, + FLAG_0x2B3, + FLAG_0x2B4, + FLAG_0x2B5, + FLAG_0x2B6, + FLAG_0x2B7, + FLAG_0x2B8, + FLAG_0x2B9, + FLAG_0x2BA }; -struct MEvent_Str_1 gUnknown_3005ED0; +struct MEvent_Str_1 sMEventSendToEReaderManager; -static EWRAM_DATA bool32 gUnknown_203F3BC = FALSE; +static EWRAM_DATA bool32 sReceivedWonderCardIsValid = FALSE; -void sub_81435DC(struct MEvent_Str_1 *mgr, size_t size, const void * data) +void SendUnknownSerialData_Init(struct MEvent_Str_1 *mgr, size_t size, const void * data) { vu16 imeBak = REG_IME; REG_IME = 0; @@ -106,7 +94,7 @@ void sub_81435DC(struct MEvent_Str_1 *mgr, size_t size, const void * data) mgr->data = data; } -void sub_8143644(struct MEvent_Str_1 *unused) +void SendUnknownSerialData_Teardown(struct MEvent_Str_1 *unused) { vu16 imeBak = REG_IME; REG_IME = 0; @@ -116,15 +104,15 @@ void sub_8143644(struct MEvent_Str_1 *unused) REG_IME = imeBak; } -u8 sub_8143674(struct MEvent_Str_1 *mgr) +u8 SendUnknownSerialData_Run(struct MEvent_Str_1 *mgr) { u8 resp = 0; mgr->status = EReaderHandleTransfer(1, mgr->size, mgr->data, 0); - if ((mgr->status & 0x13) == 0x10) + if ((mgr->status & 0x13) == 0x10) // checksum OK and xfer off resp = 1; - if (mgr->status & 8) + if (mgr->status & 8) // cancelled by player resp = 2; - if (mgr->status & 4) + if (mgr->status & 4) // timed out resp = 3; gShouldAdvanceLinkState = 0; return resp; @@ -161,32 +149,32 @@ static bool32 IsEReaderConnectionSane(void) return FALSE; } -u32 sub_8143770(u8 * r4, u16 * r5) +static u32 EReaderReceive(u8 * state_p, u16 * receiveDelay) { - if ((*r4 == 3 || *r4 == 4 || *r4 == 5) && HasLinkErrorOccurred()) + if ((*state_p == 3 || *state_p == 4 || *state_p == 5) && HasLinkErrorOccurred()) { - *r4 = 0; + *state_p = 0; return 3; } - switch (*r4) + switch (*state_p) { case 0: if (IsLinkMaster() && GetLinkPlayerCount_2() > 1) { - *r4 = 1; + *state_p = 1; ; } else if (JOY_NEW(B_BUTTON)) { - *r4 = 0; + *state_p = 0; return 1; } break; case 1: - if (++(*r5) > 5) + if (++(*receiveDelay) > 5) { - *r5 = 0; - *r4 = 2; + *receiveDelay = 0; + *state_p = 2; } break; case 2: @@ -194,19 +182,19 @@ u32 sub_8143770(u8 * r4, u16 * r5) { PlaySE(SE_PINPON); CheckShouldAdvanceLinkState(); - *r5 = 0; - *r4 = 3; + *receiveDelay = 0; + *state_p = 3; } else if (JOY_NEW(B_BUTTON)) { - *r4 = 0; + *state_p = 0; return 1; } break; case 3: - if (++(*r5) > 30) + if (++(*receiveDelay) > 30) { - *r4 = 0; + *state_p = 0; return 5; } else if (IsLinkConnectionEstablished()) @@ -215,24 +203,24 @@ u32 sub_8143770(u8 * r4, u16 * r5) { if (IsLinkPlayerDataExchangeComplete()) { - *r4 = 0; + *state_p = 0; return 2; } else - *r4 = 4; + *state_p = 4; } else - *r4 = 3; + *state_p = 3; } break; case 4: - sub_800AA80(0); - *r4 = 5; + Link_StartSend5FFFwithParam(0); + *state_p = 5; break; case 5: if (!gReceivedRemoteLinkPlayers) { - *r4 = 0; + *state_p = 0; return 4; } break; @@ -242,19 +230,19 @@ u32 sub_8143770(u8 * r4, u16 * r5) void task_add_00_ereader(void) { - u8 taskId = CreateTask(sub_8143910, 0); + u8 taskId = CreateTask(Task_EReaderComm, 0); struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data; data->state = 0; - data->t09 = 0; + data->textOrReceiveState = 0; data->t0A = 0; data->t0B = 0; data->t0C = 0; data->t0D = 0; - data->t00 = 0; + data->stateAdvanceDelay = 0; data->t02 = 0; data->t04 = 0; data->t06 = 0; - data->t0E = 0; + data->initialSendResult = 0; data->t10 = AllocZeroed(sizeof(struct MEvent_Str_2)); } @@ -273,22 +261,22 @@ static bool32 AdvanceDelayTimerCheckTimeout(u16 * a0, u16 a1) return FALSE; } -void sub_8143910(u8 taskId) +static void Task_EReaderComm(u8 taskId) { struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data; switch (data->state) { case 0: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE52)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ReceiveMysteryGiftWithEReader)) data->state = 1; break; case 1: ResetTTDataBuffer(); - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); data->state = 2; break; case 2: - if (AdvanceDelayTimerCheckTimeout(&data->t00, 10)) + if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10)) data->state = 3; break; case 3: @@ -301,22 +289,22 @@ void sub_8143910(u8 taskId) data->state = 13; break; case 4: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE53)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_SelectConnectFromEReaderMenu)) { - AddTextPrinterToWindow1(gUnknown_841DE54); - ResetDelayTimer(&data->t00); + AddTextPrinterToWindow1(gJPText_SelectConnectWithGBA); + ResetDelayTimer(&data->stateAdvanceDelay); data->state = 5; } break; case 5: - if (AdvanceDelayTimerCheckTimeout(&data->t00, 90)) + if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 90)) { ResetTTDataBuffer(); data->state = 6; } else if (JOY_NEW(B_BUTTON)) { - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); PlaySE(SE_SELECT); data->state = 23; } @@ -326,12 +314,12 @@ void sub_8143910(u8 taskId) { PlaySE(SE_SELECT); CloseLink(); - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); data->state = 23; } else if (GetLinkPlayerCount_2() > 1) { - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); CloseLink(); data->state = 7; } @@ -339,72 +327,80 @@ void sub_8143910(u8 taskId) { PlaySE(SE_SELECT); CloseLink(); - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); data->state = 8; } - else if (AdvanceDelayTimerCheckTimeout(&data->t00, 10)) + else if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10)) { CloseLink(); ResetTTDataBuffer(); - ResetDelayTimer(&data->t00); + ResetDelayTimer(&data->stateAdvanceDelay); } break; case 7: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7C)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_LinkIsIncorrect)) data->state = 4; break; case 8: - AddTextPrinterToWindow1(gUnknown_841DE95); - sub_81435DC(&gUnknown_3005ED0, gUnknownSerialData_End - gUnknownSerialData_Start, gUnknownSerialData_Start); + AddTextPrinterToWindow1(gJPText_Connecting); + SendUnknownSerialData_Init(&sMEventSendToEReaderManager, gUnknownSerialData_End - gUnknownSerialData_Start, gUnknownSerialData_Start); data->state = 9; break; case 9: - data->t0E = sub_8143674(&gUnknown_3005ED0); - if (data->t0E != 0) + data->initialSendResult = SendUnknownSerialData_Run(&sMEventSendToEReaderManager); + if (data->initialSendResult != 0) data->state = 10; break; case 10: - sub_8143644(&gUnknown_3005ED0); - if (data->t0E == 3) + SendUnknownSerialData_Teardown(&sMEventSendToEReaderManager); + if (data->initialSendResult == 3) + // Error data->state = 20; - else if (data->t0E == 1) + else if (data->initialSendResult == 1) { - ResetDelayTimer(&data->t00); - AddTextPrinterToWindow1(gUnknown_841DE9B); + // OK + ResetDelayTimer(&data->stateAdvanceDelay); + AddTextPrinterToWindow1(gJPText_PleaseWaitAMoment); data->state = 11; } else + // Try again data->state = 0; break; case 11: - if (AdvanceDelayTimerCheckTimeout(&data->t00, 840)) + if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 840)) data->state = 12; break; case 12: ResetTTDataBuffer(); - AddTextPrinterToWindow1(gUnknown_841DE98); + AddTextPrinterToWindow1(gJPText_AllowEReaderToLoadCard); data->state = 13; break; case 13: - switch (sub_8143770(&data->t09, &data->t00)) + switch (EReaderReceive(&data->textOrReceiveState, &data->stateAdvanceDelay)) { case 0: + // Running break; case 2: - AddTextPrinterToWindow1(gUnknown_841DE95); + // Done + AddTextPrinterToWindow1(gJPText_Connecting); data->state = 14; break; case 1: + // Cancelled PlaySE(SE_SELECT); CloseLink(); data->state = 23; break; case 5: + // Error Try Again CloseLink(); data->state = 21; break; case 3: case 4: + // Error CheckLink CloseLink(); data->state = 20; break; @@ -423,14 +419,14 @@ void sub_8143910(u8 taskId) } break; case 15: - data->t0E = ValidateTrainerTowerData((struct EReaderTrainerHillSet *)gDecompressionBuffer); - sub_800AA80(data->t0E); + data->initialSendResult = ValidateTrainerTowerData((struct EReaderTrainerHillSet *)gDecompressionBuffer); + Link_StartSend5FFFwithParam(data->initialSendResult); data->state = 16; break; case 16: if (!gReceivedRemoteLinkPlayers) { - if (data->t0E == 1) + if (data->initialSendResult == 1) data->state = 17; else data->state = 20; @@ -439,39 +435,39 @@ void sub_8143910(u8 taskId) case 17: if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerHillSet *)gDecompressionBuffer)) { - AddTextPrinterToWindow1(gUnknown_841DE99); - ResetDelayTimer(&data->t00); + AddTextPrinterToWindow1(gJPText_ConnectionComplete); + ResetDelayTimer(&data->stateAdvanceDelay); data->state = 18; } else data->state = 22; break; case 18: - if (AdvanceDelayTimerCheckTimeout(&data->t00, 120)) + if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 120)) { - AddTextPrinterToWindow1(gUnknown_841DE9A); - PlayFanfare(258); + AddTextPrinterToWindow1(gJPText_NewTrainerHasComeToSevii); + PlayFanfare(MUS_FANFA4); data->state = 19; } break; case 19: - if (IsFanfareTaskInactive() &&JOY_NEW(A_BUTTON | B_BUTTON)) + if (IsFanfareTaskInactive() && JOY_NEW(A_BUTTON | B_BUTTON)) data->state = 26; break; case 23: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7D)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_CardReadingHasBeenHalted)) data->state = 26; break; case 20: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE96)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ConnectionErrorCheckLink)) data->state = 0; break; case 21: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE97)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_ConnectionErrorTryAgain)) data->state = 0; break; case 22: - if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE9C)) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textOrReceiveState, gJPText_WriteErrorUnableToSaveData)) data->state = 0; break; case 26: @@ -483,10 +479,10 @@ void sub_8143910(u8 taskId) } } -void sub_8143D24(void) +void InitMEventData(void) { CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers, sizeof(gSaveBlock1Ptr->mysteryEventBuffers)); - sub_8143ED0(); + BlankMENewsJisan(); EC_ResetMEventProfileMaybe(); } @@ -517,14 +513,14 @@ u16 * GetMEventProfileECWordsMaybe(void) void DestroyWonderNews(void) { - sub_8143E9C(); + BlankWonderNews(); } -bool32 sub_8143DC8(const struct MEWonderNewsData * src) +bool32 OverwriteSavedWonderNewsWithReceivedNews(const struct MEWonderNewsData * src) { - if (!sub_8143E64(src)) + if (!IsReceivedWonderNewsHeaderValid(src)) return FALSE; - sub_8143E9C(); + BlankWonderNews(); gSaveBlock1Ptr->mysteryEventBuffers.menews.data = *src; gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData)); return TRUE; @@ -534,14 +530,14 @@ bool32 ValidateReceivedWonderNews(void) { if (CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data, sizeof(struct MEWonderNewsData)) != gSaveBlock1Ptr->mysteryEventBuffers.menews.crc) return FALSE; - if (!sub_8143E64(&gSaveBlock1Ptr->mysteryEventBuffers.menews.data)) + if (!IsReceivedWonderNewsHeaderValid(&gSaveBlock1Ptr->mysteryEventBuffers.menews.data)) return FALSE; return TRUE; } -bool32 sub_8143E64(const struct MEWonderNewsData * data) +static bool32 IsReceivedWonderNewsHeaderValid(const struct MEWonderNewsData * data) { - if (data->unk_00 == 0) + if (data->newsId == 0) return FALSE; return TRUE; } @@ -549,24 +545,24 @@ bool32 sub_8143E64(const struct MEWonderNewsData * data) bool32 WonderNews_Test_Unk_02(void) { const struct MEWonderNewsData * data = &gSaveBlock1Ptr->mysteryEventBuffers.menews.data; - if (data->unk_02 == 0) + if (data->shareState == 0) return FALSE; return TRUE; } -void sub_8143E9C(void) +static void BlankWonderNews(void) { CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->mysteryEventBuffers.menews.data)); gSaveBlock1Ptr->mysteryEventBuffers.menews.crc = 0; } -void sub_8143ED0(void) +static void BlankMENewsJisan(void) { CpuFill32(0, GetMENewsJisanStructPtr(), sizeof(struct MENewsJisanStruct)); MENewsJisanReset(); } -bool32 sub_8143EF4(const u8 * src) +bool32 MEvent_HaveAlreadyReceivedWonderNews(const u8 * src) { const u8 * r5 = (const u8 *)&gSaveBlock1Ptr->mysteryEventBuffers.menews.data; u32 i; @@ -584,22 +580,23 @@ void DestroyWonderCard(void) { BlankSavedWonderCard(); BlankMEventBuffer2(); - sub_8144790(); + BlankBuffer344(); ClearRamScript(); - sub_806E2D0(); - sub_806E370(); + ResetMysteryEventFlags(); + ResetMysteryEventVars(); ClearEReaderTrainer(&gSaveBlock2Ptr->battleTower.ereaderTrainer); } -bool32 sub_8143F68(const struct MEWonderCardData * data) +bool32 OverwriteSavedWonderCardWithReceivedCard(const struct MEWonderCardData * data) { struct MEventBuffer_3430_Sub * r2; struct MEWonderCardData * r1; - if (!sub_8144018(data)) + if (!IsReceivedWonderCardHeaderValid(data)) return FALSE; DestroyWonderCard(); memcpy(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, data, sizeof(struct MEWonderCardData)); gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData)); + // Annoying hack to match r2 = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data; r1 = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; r2->unk_06 = r1->unk_02; @@ -610,24 +607,24 @@ bool32 ValidateReceivedWonderCard(void) { if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc != CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData))) return FALSE; - if (!sub_8144018(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data)) + if (!IsReceivedWonderCardHeaderValid(&gSaveBlock1Ptr->mysteryEventBuffers.mecard.data)) return FALSE; - if (!sub_8069DFC()) + if (!ValidateRamScript()) return FALSE; return TRUE; } -bool32 sub_8144018(const struct MEWonderCardData * data) +static bool32 IsReceivedWonderCardHeaderValid(const struct MEWonderCardData * data) { - if (data->unk_00 == 0) + if (data->cardId == 0) return FALSE; if (data->unk_08_0 > 2) return FALSE; - if (!(data->unk_08_6 == 0 || data->unk_08_6 == 1 || data->unk_08_6 == 2)) + if (!(data->shareState == 0 || data->shareState == 1 || data->shareState == 2)) return FALSE; if (data->unk_08_2 > 7) return FALSE; - if (data->unk_09 > 7) + if (data->recvMonCapacity > 7) return FALSE; return TRUE; } @@ -635,18 +632,18 @@ bool32 sub_8144018(const struct MEWonderCardData * data) bool32 WonderCard_Test_Unk_08_6(void) { const struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; - if (data->unk_08_6 == 0) + if (data->shareState == 0) return FALSE; return TRUE; } -void BlankSavedWonderCard(void) +static void BlankSavedWonderCard(void) { CpuFill32(0, &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data, sizeof(struct MEWonderCardData)); gSaveBlock1Ptr->mysteryEventBuffers.mecard.crc = 0; } -void BlankMEventBuffer2(void) +static void BlankMEventBuffer2(void) { CpuFill32(0, sav1_get_mevent_buffer_2(), 18 * sizeof(u16)); gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.crc = 0; @@ -655,17 +652,17 @@ void BlankMEventBuffer2(void) u16 GetWonderCardFlagId(void) { if (ValidateReceivedWonderCard()) - return gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00; + return gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.cardId; return 0; } -void sub_814410C(struct MEWonderCardData * buffer) +void MEvent_WonderCardResetUnk08_6(struct MEWonderCardData * buffer) { - if (buffer->unk_08_6 == 1) - buffer->unk_08_6 = 0; + if (buffer->shareState == 1) + buffer->shareState = 0; } -bool32 sub_8144124(u16 a0) +static bool32 IsCardIdInValidRange(u16 a0) { if (a0 >= 1000 && a0 < 1020) return TRUE; @@ -675,33 +672,33 @@ bool32 sub_8144124(u16 a0) bool32 CheckReceivedGiftFromWonderCard(void) { u16 value = GetWonderCardFlagId(); - if (!sub_8144124(value)) + if (!IsCardIdInValidRange(value)) return FALSE; - if (FlagGet(gUnknown_8466F00[value - 1000]) == TRUE) + if (FlagGet(sGiftItemFlagIds[value - 1000]) == TRUE) return FALSE; return TRUE; } -s32 sub_8144184(const struct MEventBuffer_3430_Sub * data, s32 size) +static s32 CountReceivedDistributionMons(const struct MEventBuffer_3430_Sub * data, s32 size) { s32 r3 = 0; s32 i; for (i = 0; i < size; i++) { - if (data->unk_08[1][i] && data->unk_08[0][i]) + if (data->distributedMons[1][i] && data->distributedMons[0][i]) r3++; } return r3; } -bool32 sub_81441AC(const struct MEventBuffer_3430_Sub * data1, const u16 * data2, s32 size) +static bool32 HasPlayerAlreadyReceivedDistributedMon(const struct MEventBuffer_3430_Sub * data1, const u16 * data2, s32 size) { s32 i; for (i = 0; i < size; i++) { - if (data1->unk_08[1][i] == data2[1]) + if (data1->distributedMons[1][i] == data2[1]) return TRUE; - if (data1->unk_08[0][i] == data2[0]) + if (data1->distributedMons[0][i] == data2[0]) return TRUE; } return FALSE; @@ -718,7 +715,7 @@ static bool32 IsWonderCardSpeciesValid(const u16 * data) return TRUE; } -s32 sub_8144218(void) +static s32 ValidateCardAndCountMonsReceived(void) { struct MEWonderCardData * data; if (!ValidateReceivedWonderCard()) @@ -726,24 +723,24 @@ s32 sub_8144218(void) data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; if (data->unk_08_0 != 1) return 0; - return sub_8144184(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data->unk_09); + return CountReceivedDistributionMons(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data->recvMonCapacity); } -bool32 sub_8144254(const u16 * data) +bool32 MEvent_ReceiveDistributionMon(const u16 * data) { struct MEWonderCardData * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; - s32 size = buffer->unk_09; + s32 capacity = buffer->recvMonCapacity; s32 i; if (!IsWonderCardSpeciesValid(data)) return FALSE; - if (sub_81441AC(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data, size)) + if (HasPlayerAlreadyReceivedDistributedMon(&gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data, data, capacity)) return FALSE; - for (i = 0; i < size; i++) + for (i = 0; i < capacity; i++) { - if (gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] == 0 && gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] == 0) + if (gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[1][i] == 0 && gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[0][i] == 0) { - gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[1][i] = data[1]; - gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_08[0][i] = data[0]; + gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[1][i] = data[1]; + gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.distributedMons[0][i] = data[0]; return TRUE; } } @@ -771,9 +768,9 @@ void BuildMEventClientHeader(struct MEventClientHeaderStruct * data) if (ValidateReceivedWonderCard()) { // Populate fields - data->id = GetSavedWonderCard()->unk_00; + data->id = GetSavedWonderCard()->cardId; data->unk_20 = *sav1_get_mevent_buffer_2(); - data->unk_44 = GetSavedWonderCard()->unk_09; + data->maxDistributionMons = GetSavedWonderCard()->recvMonCapacity; } else data->id = 0; @@ -815,14 +812,14 @@ u32 sub_8144418(const u16 * a0, const struct MEventClientHeaderStruct * a1, void return 2; } -u32 sub_8144434(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused) +u32 MEvent_CanPlayerReceiveDistributionMon(const u16 * a0, const struct MEventClientHeaderStruct * a1, void * unused) { - s32 r4 = a1->unk_44 - sub_8144184(&a1->unk_20, a1->unk_44); - if (r4 == 0) + s32 numSpaces = a1->maxDistributionMons - CountReceivedDistributionMons(&a1->unk_20, a1->maxDistributionMons); + if (numSpaces == 0) return 1; - if (sub_81441AC(&a1->unk_20, a0, a1->unk_44)) + if (HasPlayerAlreadyReceivedDistributedMon(&a1->unk_20, a0, a1->maxDistributionMons)) return 3; - if (r4 == 1) + if (numSpaces == 1) return 4; return 2; } @@ -838,9 +835,9 @@ bool32 sub_8144474(const struct MEventClientHeaderStruct * a0, const u16 * a1) return TRUE; } -s32 sub_814449C(const struct MEventClientHeaderStruct * a0) +static s32 GetNumReceivedDistributionMons(const struct MEventClientHeaderStruct * a0) { - return sub_8144184(&a0->unk_20, a0->unk_44); + return CountReceivedDistributionMons(&a0->unk_20, a0->maxDistributionMons); } u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command) @@ -848,22 +845,23 @@ u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command) switch (command) { case 0: - return a0->unk_20.unk_00; + return a0->unk_20.linkWins; case 1: - return a0->unk_20.unk_02; + return a0->unk_20.linkLosses; case 2: - return a0->unk_20.unk_04; + return a0->unk_20.linkTrades; case 3: - return sub_814449C(a0); + return GetNumReceivedDistributionMons(a0); case 4: - return a0->unk_44; + return a0->maxDistributionMons; default: AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 825); return 0; } } -void sub_814451C(u32 command) +// Increments an interaction count in the save block +static void IncrementBattleCardCount(u32 command) { struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; if (data->unk_08_0 == 2) @@ -872,13 +870,13 @@ void sub_814451C(u32 command) switch (command) { case 0: - dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_00; + dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkWins; break; case 1: - dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_02; + dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkLosses; break; case 2: - dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.unk_04; + dest = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data.linkTrades; break; case 3: break; @@ -896,7 +894,7 @@ void sub_814451C(u32 command) } } -u16 sub_81445C0(u32 command) +u16 MEvent_GetBattleCardCount(u32 command) { switch (command) { @@ -906,7 +904,7 @@ u16 sub_81445C0(u32 command) if (data->unk_08_0 == 2) { struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data; - return buffer->unk_00; + return buffer->linkWins; } break; } @@ -916,7 +914,7 @@ u16 sub_81445C0(u32 command) if (data->unk_08_0 == 2) { struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data; - return buffer->unk_02; + return buffer->linkLosses; } break; } @@ -926,7 +924,7 @@ u16 sub_81445C0(u32 command) if (data->unk_08_0 == 2) { struct MEventBuffer_3430_Sub * buffer = &gSaveBlock1Ptr->mysteryEventBuffers.buffer_310.data; - return buffer->unk_04; + return buffer->linkTrades; } break; } @@ -934,14 +932,14 @@ u16 sub_81445C0(u32 command) { struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; if (data->unk_08_0 == 1) - return sub_8144218(); + return ValidateCardAndCountMonsReceived(); break; } case 4: { struct MEWonderCardData * data = &gSaveBlock1Ptr->mysteryEventBuffers.mecard.data; if (data->unk_08_0 == 1) - return data->unk_09; + return data->recvMonCapacity; break; } } @@ -949,38 +947,38 @@ u16 sub_81445C0(u32 command) return 0; } -void sub_81446C4(void) +void ResetReceivedWonderCardFlag(void) { - gUnknown_203F3BC = FALSE; + sReceivedWonderCardIsValid = FALSE; } -bool32 sub_81446D0(u16 a0) +bool32 MEventHandleReceivedWonderCard(u16 cardId) { - gUnknown_203F3BC = FALSE; - if (a0 == 0) + sReceivedWonderCardIsValid = FALSE; + if (cardId == 0) return FALSE; if (!ValidateReceivedWonderCard()) return FALSE; - if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.unk_00 != a0) + if (gSaveBlock1Ptr->mysteryEventBuffers.mecard.data.cardId != cardId) return FALSE; - gUnknown_203F3BC = TRUE; + sReceivedWonderCardIsValid = TRUE; return TRUE; } -void sub_8144714(u32 a0, u32 a1) +void MEvent_RecordIdOfWonderCardSenderByEventType(u32 eventId, u32 trainerId) { - if (gUnknown_203F3BC) + if (sReceivedWonderCardIsValid) { - switch (a0) + switch (eventId) { - case 2: - sub_8144824(2, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[1], 5); + case 2: // trade + RecordIdOfWonderCardSender(2, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[1], 5); break; - case 0: - sub_8144824(0, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5); + case 0: // link win + RecordIdOfWonderCardSender(0, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5); break; - case 1: - sub_8144824(1, a1, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5); + case 1: // link loss + RecordIdOfWonderCardSender(1, trainerId, gSaveBlock1Ptr->mysteryEventBuffers.unk_344[0], 5); break; default: AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 988); @@ -988,43 +986,48 @@ void sub_8144714(u32 a0, u32 a1) } } -void sub_8144790(void) +static void BlankBuffer344(void) { CpuFill32(0, gSaveBlock1Ptr->mysteryEventBuffers.unk_344, sizeof(gSaveBlock1Ptr->mysteryEventBuffers.unk_344)); } -bool32 sub_81447BC(u32 a0, u32 * a1, s32 size) +// Looks up trainerId in an array idsList with count elements. +// If trainerId is found, rearranges idsList to put it in the front. +// Otherwise, drops the last element of the list and inserts +// trainerId at the front. +// Returns TRUE in the latter case. +static bool32 PlaceTrainerIdAtFrontOfList(u32 trainerId, u32 * idsList, s32 count) { s32 i; s32 j; - for (i = 0; i < size; i++) + for (i = 0; i < count; i++) { - if (a1[i] == a0) + if (idsList[i] == trainerId) break; } - if (i == size) + if (i == count) { - for (j = size - 1; j > 0; j--) + for (j = count - 1; j > 0; j--) { - a1[j] = a1[j - 1]; + idsList[j] = idsList[j - 1]; } - a1[0] = a0; + idsList[0] = trainerId; return TRUE; } else { for (j = i; j > 0; j--) { - a1[j] = a1[j - 1]; + idsList[j] = idsList[j - 1]; } - a1[0] = a0; + idsList[0] = trainerId; return FALSE; } } -void sub_8144824(u32 a0, u32 a1, u32 * a2, s32 a3) +static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 * idsList, s32 count) { - if (sub_81447BC(a1, a2, a3)) - sub_814451C(a0); + if (PlaceTrainerIdAtFrontOfList(trainerId, idsList, count)) + IncrementBattleCardCount(eventId); } diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c deleted file mode 100644 index 3de09ab44..000000000 --- a/src/mevent_8145654.c +++ /dev/null @@ -1,793 +0,0 @@ -#include "global.h" -#include "constants/species.h" -#include "bg.h" -#include "gpu_regs.h" -#include "palette.h" -#include "decompress.h" -#include "malloc.h" -#include "menu.h" -#include "new_menu_helpers.h" -#include "pokemon_icon.h" -#include "mystery_gift_menu.h" -#include "menu_indicators.h" -#include "string_util.h" -#include "link_rfu.h" -#include "mevent.h" -#include "battle_anim.h" - -struct UnkStruct_8467FB8 -{ - u8 textPal1:4; - u8 textPal2:4; - u8 textPal3:4; - u8 textPal4:4; - const u8 * tiles; - const u8 * map; - const u16 * pal; -}; - -struct UnkStruct_203F3C8_02DC -{ - u8 unk_00; - u8 unk_01[41]; - u8 unk_42[4]; -}; - -struct UnkStruct_203F3C8 -{ - /*0000*/ struct MEWonderCardData unk_0000; - /*014c*/ struct MEventBuffer_3430_Sub unk_014C; - /*0170*/ const struct UnkStruct_8467FB8 * unk_0170; - /*0174*/ u8 unk_0174; - /*0175*/ u8 unk_0175; - /*0176*/ u16 unk_0176[3]; - /*017C*/ u8 unk_017C; - /*017D*/ u8 unk_017D[7][2]; - /*018B*/ u8 unk_018B[41]; - /*01B4*/ u8 unk_01B4[41]; - /*01DD*/ u8 unk_01DD[7]; - /*01E4*/ u8 unk_01E4[4][41]; - /*0288*/ u8 unk_0288[41]; - /*02B1*/ u8 unk_02B1[41]; - /*02DC*/ struct UnkStruct_203F3C8_02DC unk_02DC[8]; - /*045C*/ u8 buffer_045C[0x1000]; -}; - -EWRAM_DATA struct UnkStruct_203F3C8 * gUnknown_203F3C8 = NULL; - -void sub_8145A98(void); -void sub_8145D18(u8 whichWindow); -void sub_8146060(void); -void sub_81461D8(void); - -const u8 gUnknown_8467068[][3] = { - {0, 2, 3}, - {0, 1, 2} -}; -const u8 ALIGNED(4) gUnknown_8467070[3] = {7, 4, 7}; -const struct WindowTemplate gUnknown_8467074[] = { - {0x01, 0x01, 0x01, 0x19, 0x04, 0x0f, 0x029c}, - {0x01, 0x01, 0x06, 0x1c, 0x08, 0x0f, 0x01bc}, - {0x01, 0x01, 0x0e, 0x1c, 0x05, 0x0f, 0x0130} -}; - -const u16 gUnknown_846708C[] = INCBIN_U16("data/graphics/mevent/pal_46708C.gbapal"); -const u16 gUnknown_84670AC[] = INCBIN_U16("data/graphics/mevent/pal_4670AC.gbapal"); -const u16 gUnknown_84670CC[] = INCBIN_U16("data/graphics/mevent/pal_4670CC.gbapal"); -const u16 gUnknown_84670EC[] = INCBIN_U16("data/graphics/mevent/pal_4670EC.gbapal"); -const u16 gUnknown_846710C[] = INCBIN_U16("data/graphics/mevent/pal_46710C.gbapal"); -const u16 gUnknown_846712C[] = INCBIN_U16("data/graphics/mevent/pal_46712C.gbapal"); -const u16 gUnknown_846714C[] = INCBIN_U16("data/graphics/mevent/pal_46714C.gbapal"); -const u16 gUnknown_846716C[] = INCBIN_U16("data/graphics/mevent/pal_46716C.gbapal"); -const u8 gUnknown_846718C[] = INCBIN_U8("data/graphics/mevent/gfx_46718C.4bpp.lz"); -const u8 gUnknown_8467288[] = INCBIN_U8("data/graphics/mevent/tilemap_467288.bin.lz"); -const u8 gUnknown_846737C[] = INCBIN_U8("data/graphics/mevent/gfx_46737C.4bpp.lz"); -const u8 gUnknown_8467470[] = INCBIN_U8("data/graphics/mevent/tilemap_467470.bin.lz"); -const u8 gUnknown_8467558[] = INCBIN_U8("data/graphics/mevent/gfx_467558.4bpp.lz"); -const u8 gUnknown_846762C[] = INCBIN_U8("data/graphics/mevent/tilemap_46762C.bin.lz"); -const u8 gUnknown_8467700[] = INCBIN_U8("data/graphics/mevent/gfx_467700.4bpp.lz"); -const u8 gUnknown_8467934[] = INCBIN_U8("data/graphics/mevent/tilemap_467934.bin.lz"); -const u8 gUnknown_8467A7C[] = INCBIN_U8("data/graphics/mevent/gfx_467A7C.4bpp.lz"); -const u8 gUnknown_8467CAC[] = INCBIN_U8("data/graphics/mevent/tilemap_467CAC.bin.lz"); -const u16 gUnknown_8467DF4[] = INCBIN_U16("data/graphics/mevent/pal_467DF4.gbapal"); -const u16 gUnknown_8467E14[] = INCBIN_U16("data/graphics/mevent/pal_467E14.gbapal"); -const u16 gUnknown_8467E34[] = INCBIN_U16("data/graphics/mevent/pal_467E34.gbapal"); -const u16 gUnknown_8467E54[] = INCBIN_U16("data/graphics/mevent/pal_467E54.gbapal"); -const u16 gUnknown_8467E74[] = INCBIN_U16("data/graphics/mevent/pal_467E74.gbapal"); -const u16 gUnknown_8467E94[] = INCBIN_U16("data/graphics/mevent/pal_467E94.gbapal"); -const u16 gUnknown_8467EB4[] = INCBIN_U16("data/graphics/mevent/pal_467EB4.gbapal"); -const u16 gUnknown_8467ED4[] = INCBIN_U16("data/graphics/mevent/pal_467ED4.gbapal"); -const u32 gUnknown_8467EF4[] = INCBIN_U32("data/graphics/mevent/gfx_467EF4.4bpp.lz"); - -const struct CompressedSpriteSheet gUnknown_8467F58 = { - gUnknown_8467EF4, 0x100, 0x8000 -}; -const struct SpritePalette gUnknown_8467F60[] = { - {gUnknown_8467DF4, 0x8000}, - {gUnknown_8467E14, 0x8000}, - {gUnknown_8467E34, 0x8000}, - {gUnknown_8467E54, 0x8000}, - {gUnknown_8467E74, 0x8000}, - {gUnknown_8467E94, 0x8000}, - {gUnknown_8467EB4, 0x8000}, - {gUnknown_8467ED4, 0x8000} -}; -const struct SpriteTemplate gUnknown_8467FA0 = { - 0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy -}; -const struct UnkStruct_8467FB8 gUnknown_8467FB8[8] = { - {1, 0, 0, 0, gUnknown_846718C, gUnknown_8467288, gUnknown_846708C}, - {1, 0, 0, 1, gUnknown_846737C, gUnknown_8467470, gUnknown_84670AC}, - {1, 0, 0, 2, gUnknown_8467558, gUnknown_846762C, gUnknown_84670CC}, - {1, 0, 0, 3, gUnknown_8467558, gUnknown_846762C, gUnknown_84670EC}, - {1, 0, 0, 4, gUnknown_8467558, gUnknown_846762C, gUnknown_846710C}, - {1, 0, 0, 5, gUnknown_8467558, gUnknown_846762C, gUnknown_846712C}, - {1, 0, 0, 6, gUnknown_8467700, gUnknown_8467934, gUnknown_846714C}, - {1, 0, 0, 7, gUnknown_8467A7C, gUnknown_8467CAC, gUnknown_846716C} -}; - -bool32 InitWonderCardResources(struct MEWonderCardData * r5, struct MEventBuffer_3430_Sub * r6) -{ - if (r5 == NULL || r6 == NULL) - return FALSE; - gUnknown_203F3C8 = AllocZeroed(sizeof(struct UnkStruct_203F3C8)); - if (gUnknown_203F3C8 == NULL) - return FALSE; - gUnknown_203F3C8->unk_0000 = *r5; - gUnknown_203F3C8->unk_014C = *r6; - if (gUnknown_203F3C8->unk_0000.unk_08_2 >= NELEMS(gUnknown_8467FB8)) - gUnknown_203F3C8->unk_0000.unk_08_2 = 0; - if (gUnknown_203F3C8->unk_0000.unk_08_0 >= NELEMS(gUnknown_8467070)) - gUnknown_203F3C8->unk_0000.unk_08_0 = 0; - if (gUnknown_203F3C8->unk_0000.unk_09 > NELEMS(gUnknown_203F3C8->unk_017D)) - gUnknown_203F3C8->unk_0000.unk_09 = 0; - gUnknown_203F3C8->unk_0170 = &gUnknown_8467FB8[gUnknown_203F3C8->unk_0000.unk_08_2]; - return TRUE; -} - -void DestroyWonderCardResources(void) -{ - if (gUnknown_203F3C8 != NULL) - { - *gUnknown_203F3C8 = (struct UnkStruct_203F3C8){}; - Free(gUnknown_203F3C8); - gUnknown_203F3C8 = NULL; - } -} - -s32 FadeToWonderCardMenu(void) -{ - if (gUnknown_203F3C8 == NULL) - return -1; - switch(gUnknown_203F3C8->unk_0174) - { - case 0: - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - break; - case 1: - if (UpdatePaletteFade()) - return 0; - break; - case 2: - FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(1); - CopyBgTilemapBufferToVram(2); - DecompressAndCopyTileDataToVram(2, gUnknown_203F3C8->unk_0170->tiles, 0, 0x008, 0); - gUnknown_203F3C8->unk_0176[0] = AddWindow(&gUnknown_8467074[0]); - gUnknown_203F3C8->unk_0176[1] = AddWindow(&gUnknown_8467074[1]); - gUnknown_203F3C8->unk_0176[2] = AddWindow(&gUnknown_8467074[2]); - break; - case 3: - if (FreeTempTileDataBuffersIfPossible()) - return 0; - gPaletteFade.bufferTransferDisabled = TRUE; - LoadPalette(gUnknown_203F3C8->unk_0170->pal, 0x10, 0x20); - LZ77UnCompWram(gUnknown_203F3C8->unk_0170->map, gUnknown_203F3C8->buffer_045C); - CopyRectToBgTilemapBufferRect(2, gUnknown_203F3C8->buffer_045C, 0, 0, 30, 20, 0, 0, 30, 20, 1, 0x008, 0); - CopyBgTilemapBufferToVram(2); - break; - case 4: - sub_8145A98(); - break; - case 5: - sub_8145D18(0); - sub_8145D18(1); - sub_8145D18(2); - CopyBgTilemapBufferToVram(1); - break; - case 6: - LoadMonIconPalettes(); - break; - case 7: - ShowBg(1); - ShowBg(2); - gPaletteFade.bufferTransferDisabled = FALSE; - sub_8146060(); - BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); - UpdatePaletteFade(); - break; - default: - if (UpdatePaletteFade()) - return 0; - gUnknown_203F3C8->unk_0174 = 0; - return 1; - } - ++gUnknown_203F3C8->unk_0174; - return 0; -} - -s32 FadeOutFromWonderCard(bool32 flag) -{ - if (gUnknown_203F3C8 == NULL) - return -1; - switch (gUnknown_203F3C8->unk_0174) - { - case 0: - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - break; - case 1: - if (UpdatePaletteFade()) - return 0; - break; - case 2: - FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(1); - CopyBgTilemapBufferToVram(2); - break; - case 3: - HideBg(1); - HideBg(2); - RemoveWindow(gUnknown_203F3C8->unk_0176[2]); - RemoveWindow(gUnknown_203F3C8->unk_0176[1]); - RemoveWindow(gUnknown_203F3C8->unk_0176[0]); - break; - case 4: - sub_81461D8(); - FreeMonIconPalettes(); - break; - case 5: - PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag); - break; - case 6: - CopyBgTilemapBufferToVram(0); - BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); - break; - default: - if (UpdatePaletteFade()) - return 0; - gUnknown_203F3C8->unk_0174 = 0; - return 1; - } - ++gUnknown_203F3C8->unk_0174; - return 0; -} - -void sub_8145A98(void) -{ - u16 i = 0; - u16 r6; - u16 sp0[3] = {0, 0, 0}; - - memcpy(gUnknown_203F3C8->unk_018B, gUnknown_203F3C8->unk_0000.unk_0A, 40); - gUnknown_203F3C8->unk_018B[40] = EOS; - memcpy(gUnknown_203F3C8->unk_01B4, gUnknown_203F3C8->unk_0000.unk_32, 40); - gUnknown_203F3C8->unk_01B4[40] = EOS; - if (gUnknown_203F3C8->unk_0000.unk_04 > 999999) - gUnknown_203F3C8->unk_0000.unk_04 = 999999; - ConvertIntToDecimalStringN(gUnknown_203F3C8->unk_01DD, gUnknown_203F3C8->unk_0000.unk_04, STR_CONV_MODE_LEFT_ALIGN, 6); - for (i = 0; i < 4; i++) - { - memcpy(gUnknown_203F3C8->unk_01E4[i], gUnknown_203F3C8->unk_0000.unk_5A[i], 40); - gUnknown_203F3C8->unk_01E4[i][40] = EOS; - } - memcpy(gUnknown_203F3C8->unk_0288, gUnknown_203F3C8->unk_0000.unk_FA, 40); - gUnknown_203F3C8->unk_0288[40] = EOS; - switch (gUnknown_203F3C8->unk_0000.unk_08_0) - { - case 0: - memcpy(gUnknown_203F3C8->unk_02B1, gUnknown_203F3C8->unk_0000.unk_122, 40); - gUnknown_203F3C8->unk_02B1[40] = EOS; - break; - case 1: - gUnknown_203F3C8->unk_02B1[00] = EOS; - break; - case 2: - gUnknown_203F3C8->unk_02B1[00] = EOS; - sp0[0] = gUnknown_203F3C8->unk_014C.unk_00 < 999 ? gUnknown_203F3C8->unk_014C.unk_00 : 999; - sp0[1] = gUnknown_203F3C8->unk_014C.unk_02 < 999 ? gUnknown_203F3C8->unk_014C.unk_02 : 999; - sp0[2] = gUnknown_203F3C8->unk_014C.unk_04 < 999 ? gUnknown_203F3C8->unk_014C.unk_04 : 999; - for (i = 0; i < 8; i++) - { - memset(gUnknown_203F3C8->unk_02DC[i].unk_42, EOS, 4); - memset(gUnknown_203F3C8->unk_02DC[i].unk_01, EOS, 41); - } - for (i = 0, r6 = 0; i < 40; i++) - { - if (gUnknown_203F3C8->unk_0000.unk_122[i] != 0xF7) - { - gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_01[r6] = gUnknown_203F3C8->unk_0000.unk_122[i]; - r6++; - } - else - { - u8 r3 = gUnknown_203F3C8->unk_0000.unk_122[i + 1]; - if (r3 > 2) - { - i += 2; - } - else - { - ConvertIntToDecimalStringN(gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_42, sp0[r3], STR_CONV_MODE_LEADING_ZEROS, 3); - gUnknown_203F3C8->unk_02DC[gUnknown_203F3C8->unk_0175].unk_00 = gUnknown_203F3C8->unk_0000.unk_122[i + 2]; - gUnknown_203F3C8->unk_0175++; - if (gUnknown_203F3C8->unk_0175 > 7) - break; - r6 = 0; - i += 2; - } - } - } - } -} - -void sub_8145D18(u8 whichWindow) -{ - s8 sp0C = 0; - s32 windowId = gUnknown_203F3C8->unk_0176[whichWindow]; - PutWindowTilemap(windowId); - FillWindowPixelBuffer(windowId, 0); - switch (whichWindow) - { - case 0: - { - s32 x; - AddTextPrinterParameterized3(windowId, 3, 0, 1, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_018B); - x = 160 - GetStringWidth(3, gUnknown_203F3C8->unk_01B4, GetFontAttribute(3, 2)); - if (x < 0) - x = 0; - AddTextPrinterParameterized3(windowId, 3, x, 17, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_01B4); - if (gUnknown_203F3C8->unk_0000.unk_04 != 0) - { - AddTextPrinterParameterized3(windowId, 2, 166, 17, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal1], 0, gUnknown_203F3C8->unk_01DD); - } - break; - } - case 1: - for (; sp0C < 4; sp0C++) - { - AddTextPrinterParameterized3(windowId, 3, 0, 16 * sp0C + 2, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal2], 0, gUnknown_203F3C8->unk_01E4[sp0C]); - } - break; - case 2: - AddTextPrinterParameterized3(windowId, 3, 0, gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0], gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_0288); - if (gUnknown_203F3C8->unk_0000.unk_08_0 != 2) - { - AddTextPrinterParameterized3(windowId, 3, 0, 16 + gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0], gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02B1); - } - else - { - s32 x = 0; - s32 y = gUnknown_8467070[gUnknown_203F3C8->unk_0000.unk_08_0] + 16; - s32 spacing = GetFontAttribute(3, 2); - for (; sp0C < gUnknown_203F3C8->unk_0175; sp0C++) - { - AddTextPrinterParameterized3(windowId, 3, x, y, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02DC[sp0C].unk_01); - if (gUnknown_203F3C8->unk_02DC[sp0C].unk_42[0] != EOS) - { - x += GetStringWidth(3, gUnknown_203F3C8->unk_02DC[sp0C].unk_01, spacing); - AddTextPrinterParameterized3(windowId, 2, x, y, gUnknown_8467068[gUnknown_203F3C8->unk_0170->textPal3], 0, gUnknown_203F3C8->unk_02DC[sp0C].unk_42); - x += GetStringWidth(3, gUnknown_203F3C8->unk_02DC[sp0C].unk_42, spacing) + gUnknown_203F3C8->unk_02DC[sp0C].unk_00; - } - } - } - break; - } - CopyWindowToVram(windowId, 3); -} - -void sub_8146060(void) -{ - u8 r7 = 0; - gUnknown_203F3C8->unk_017C = 0xFF; - if (gUnknown_203F3C8->unk_014C.unk_06 != SPECIES_NONE) - { - gUnknown_203F3C8->unk_017C = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(gUnknown_203F3C8->unk_014C.unk_06), SpriteCallbackDummy, 0xDC, 0x14, 0, FALSE); - gSprites[gUnknown_203F3C8->unk_017C].oam.priority = 2; - } - if (gUnknown_203F3C8->unk_0000.unk_09 != 0 && gUnknown_203F3C8->unk_0000.unk_08_0 == 1) - { - LoadCompressedSpriteSheetUsingHeap(&gUnknown_8467F58); - LoadSpritePalette(&gUnknown_8467F60[gUnknown_203F3C8->unk_0170->textPal4]); - for (; r7 < gUnknown_203F3C8->unk_0000.unk_09; r7++) - { - gUnknown_203F3C8->unk_017D[r7][0] = 0xFF; - gUnknown_203F3C8->unk_017D[r7][1] = 0xFF; - gUnknown_203F3C8->unk_017D[r7][0] = CreateSprite(&gUnknown_8467FA0, 0xd8 - 32 * r7, 0x90, 8); - if (gUnknown_203F3C8->unk_014C.unk_08[0][r7] != 0) - { - gUnknown_203F3C8->unk_017D[r7][1] = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(gUnknown_203F3C8->unk_014C.unk_08[0][r7]), SpriteCallbackDummy, 0xd8 - 32 * r7, 0x88, 0, 0); - gSprites[gUnknown_203F3C8->unk_017D[r7][1]].oam.priority = 2; - } - } - } -} - -void sub_81461D8(void) -{ - u8 r6 = 0; - if (gUnknown_203F3C8->unk_017C != 0xFF) - DestroyMonIcon(&gSprites[gUnknown_203F3C8->unk_017C]); - if (gUnknown_203F3C8->unk_0000.unk_09 != 0 && gUnknown_203F3C8->unk_0000.unk_08_0 == 1) - { - for (; r6 < gUnknown_203F3C8->unk_0000.unk_09; r6++) - { - if (gUnknown_203F3C8->unk_017D[r6][0] != 0xFF) - { - DestroySprite(&gSprites[gUnknown_203F3C8->unk_017D[r6][0]]); - // This might be a typo. Uncomment the next line, and comment the one that follows, to get the presumed intended behavior. - // if (gUnknown_203F3C8->unk_017D[r6][1] != 0xFF) - if (gUnknown_203F3C8->unk_017D[r6][0] != 0xFF) - { - DestroyMonIcon(&gSprites[gUnknown_203F3C8->unk_017D[r6][1]]); - } - } - } - FreeSpriteTilesByTag(0x8000); - FreeSpritePaletteByTag(0x8000); - } -} - -struct UnkStruct_203F3CC -{ - /*0000*/ struct MEWonderNewsData unk_0000; - /*01bc*/ const struct UnkStruct_8467FB8 * unk_01BC; - /*01c0*/ u8 unk_01C0_0:1; - u8 unk_01C0_1:7; - /*01c1*/ u8 unk_01C1; - /*01c2*/ u8 unk_01C2_0:1; - u8 unk_01C2_1:7; - /*01c3*/ u8 unk_01C3_0:1; - u8 unk_01C3_1:7; - /*01c4*/ u16 unk_01C4; - /*01c6*/ u16 unk_01C6; - /*01c8*/ u16 unk_01C8[2]; - /*01cc*/ u8 filler_01CC[2]; - /*01ce*/ u8 unk_01CE[41]; - /*01f7*/ u8 unk_01F7[10][41]; - /*0394*/ struct ScrollArrowsTemplate unk_0394; - /*03a4*/ u8 buffer_03A4[0x1000]; -}; - -EWRAM_DATA struct UnkStruct_203F3CC * gUnknown_203F3CC = NULL; - -void sub_8146980(void); -void sub_8146A30(void); -void sub_8146B58(void); - -const u8 gUnknown_8468038[][3] = { - {0, 2, 3}, - {0, 1, 2} -}; -const struct WindowTemplate gUnknown_8468040[] = { - {0, 1, 0, 28, 3, 15, 0x000}, - {2, 1, 3, 28, 20, 15, 0x000} -}; -const struct ScrollArrowsTemplate gUnknown_8468050 = { - 0x02, 0xe8, 0x18, 0x03, 0xe8, 0x98, - 0x0000, 0x0002, 0x1000, 0x1000, 0x0, -}; - -const u16 gUnknown_8468060[] = INCBIN_U16("data/graphics/mevent/pal_468060.gbapal"); -const u16 gUnknown_8468080[] = INCBIN_U16("data/graphics/mevent/pal_468080.gbapal"); -const u16 gUnknown_84680A0[] = INCBIN_U16("data/graphics/mevent/pal_4680A0.gbapal"); -const u8 gUnknown_84680C0[] = INCBIN_U8("data/graphics/mevent/gfx_4680C0.4bpp.lz"); -const u8 gUnknown_8468140[] = INCBIN_U8("data/graphics/mevent/tilemap_468140.bin.lz"); -const u8 gUnknown_846821C[] = INCBIN_U8("data/graphics/mevent/gfx_46821C.4bpp.lz"); -const u8 gUnknown_846824C[] = INCBIN_U8("data/graphics/mevent/tilemap_46824C.bin.lz"); -const u8 gUnknown_846830C[] = INCBIN_U8("data/graphics/mevent/gfx_46830C.4bpp.lz"); -const u8 gUnknown_846837C[] = INCBIN_U8("data/graphics/mevent/tilemap_46837C.bin.lz"); -const u8 gUnknown_8468448[] = INCBIN_U8("data/graphics/mevent/gfx_468448.4bpp.lz"); -const u8 gUnknown_84684D8[] = INCBIN_U8("data/graphics/mevent/tilemap_4684D8.bin.lz"); -const u8 gUnknown_84685B4[] = INCBIN_U8("data/graphics/mevent/gfx_4685B4.4bpp.lz"); -const u8 gUnknown_8468644[] = INCBIN_U8("data/graphics/mevent/tilemap_468644.bin.lz"); - -const struct UnkStruct_8467FB8 gUnknown_8468720[] = { - {1, 0, 0, 0, gUnknown_84680C0, gUnknown_8468140, gUnknown_8468060}, - {1, 0, 0, 0, gUnknown_846821C, gUnknown_846824C, gUnknown_84670AC}, - {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_84670CC}, - {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_84670EC}, - {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_846710C}, - {1, 0, 0, 0, gUnknown_846830C, gUnknown_846837C, gUnknown_846712C}, - {1, 0, 0, 0, gUnknown_8468448, gUnknown_84684D8, gUnknown_8468080}, - {1, 0, 0, 0, gUnknown_84685B4, gUnknown_8468644, gUnknown_84680A0} -}; - -bool32 InitWonderNewsResources(const struct MEWonderNewsData * a0) -{ - if (a0 == NULL) - return FALSE; - gUnknown_203F3CC = AllocZeroed(sizeof(struct UnkStruct_203F3CC)); - if (gUnknown_203F3CC == NULL) - return FALSE; - gUnknown_203F3CC->unk_0000 = *a0; - if (gUnknown_203F3CC->unk_0000.unk_03 >= NELEMS(gUnknown_8468720)) - gUnknown_203F3CC->unk_0000.unk_03 = 0; - gUnknown_203F3CC->unk_01BC = &gUnknown_8468720[gUnknown_203F3CC->unk_0000.unk_03]; - gUnknown_203F3CC->unk_01C1 = 0xFF; - return TRUE; -} - -void DestroyWonderNewsResources(void) -{ - if (gUnknown_203F3CC != NULL) - { - *gUnknown_203F3CC = (struct UnkStruct_203F3CC){}; - Free(gUnknown_203F3CC); - gUnknown_203F3CC = NULL; - } -} - -s32 FadeToWonderNewsMenu(void) -{ - if (gUnknown_203F3CC == NULL) - return -1; - - switch (gUnknown_203F3CC->unk_01C0_1) - { - case 0: - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - break; - case 1: - if (UpdatePaletteFade()) - return 0; - ChangeBgY(0, 0, 0); - ChangeBgY(1, 0, 0); - ChangeBgY(2, 0, 0); - ChangeBgY(3, 0, 0); - SetGpuReg(REG_OFFSET_WIN0H, 0xF0); - SetGpuReg(REG_OFFSET_WIN0V, 0x1A98); - SetGpuReg(REG_OFFSET_WININ, 0x1F); - SetGpuReg(REG_OFFSET_WINOUT, 0x1B); - SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); - break; - case 2: - FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 20); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(1); - CopyBgTilemapBufferToVram(2); - CopyBgTilemapBufferToVram(3); - DecompressAndCopyTileDataToVram(3, gUnknown_203F3CC->unk_01BC->tiles, 0, 8, 0); - gUnknown_203F3CC->unk_01C8[0] = AddWindow(&gUnknown_8468040[0]); - gUnknown_203F3CC->unk_01C8[1] = AddWindow(&gUnknown_8468040[1]); - break; - case 3: - if (FreeTempTileDataBuffersIfPossible()) - return 0; - gPaletteFade.bufferTransferDisabled = TRUE; - LoadPalette(gUnknown_203F3CC->unk_01BC->pal, 0x10, 0x20); - LZ77UnCompWram(gUnknown_203F3CC->unk_01BC->map, gUnknown_203F3CC->buffer_03A4); - CopyRectToBgTilemapBufferRect(1, gUnknown_203F3CC->buffer_03A4, 0, 0, 30, 3, 0, 0, 30, 3, 1, 8, 0); - CopyRectToBgTilemapBufferRect(3, gUnknown_203F3CC->buffer_03A4, 0, 3, 30, 23, 0, 3, 30, 23, 1, 8, 0); - CopyBgTilemapBufferToVram(1); - CopyBgTilemapBufferToVram(3); - break; - case 4: - sub_8146980(); - break; - case 5: - sub_8146A30(); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(2); - break; - case 6: - ShowBg(1); - ShowBg(2); - ShowBg(3); - gPaletteFade.bufferTransferDisabled = FALSE; - gUnknown_203F3CC->unk_01C1 = AddScrollIndicatorArrowPair(&gUnknown_203F3CC->unk_0394, &gUnknown_203F3CC->unk_01C6); - BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); - UpdatePaletteFade(); - break; - default: - if (UpdatePaletteFade()) - return 0; - gUnknown_203F3CC->unk_01C0_1 = 0; - return 1; - } - - ++gUnknown_203F3CC->unk_01C0_1; - return 0; -} - -s32 FadeOutFromWonderNews(bool32 flag) -{ - if (gUnknown_203F3CC == NULL) - return -1; - switch (gUnknown_203F3CC->unk_01C0_1) - { - case 0: - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - break; - case 1: - if (UpdatePaletteFade()) - return 0; - ChangeBgY(2, 0, 0); - SetGpuReg(REG_OFFSET_WIN0H, 0); - SetGpuReg(REG_OFFSET_WIN0V, 0); - SetGpuReg(REG_OFFSET_WININ, 0); - SetGpuReg(REG_OFFSET_WINOUT, 0); - ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); - break; - case 2: - FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); - FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 24); - FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 24); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(1); - CopyBgTilemapBufferToVram(2); - CopyBgTilemapBufferToVram(3); - break; - case 3: - HideBg(1); - HideBg(2); - RemoveWindow(gUnknown_203F3CC->unk_01C8[1]); - RemoveWindow(gUnknown_203F3CC->unk_01C8[0]); - break; - case 4: - ChangeBgY(2, 0, 0); - ChangeBgY(3, 0, 0); - if (gUnknown_203F3CC->unk_01C1 != 0xFF) - { - RemoveScrollIndicatorArrowPair(gUnknown_203F3CC->unk_01C1); - gUnknown_203F3CC->unk_01C1 = 0xFF; - } - break; - case 5: - PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag); - break; - case 6: - MG_DrawCheckerboardPattern(); - CopyBgTilemapBufferToVram(0); - CopyBgTilemapBufferToVram(3); - BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); - break; - default: - if (UpdatePaletteFade()) - return 0; - gUnknown_203F3CC->unk_01C0_1 = 0; - return 1; - } - ++gUnknown_203F3CC->unk_01C0_1; - return 0; -} - -void MENews_RemoveScrollIndicatorArrowPair(void) -{ - if (!gUnknown_203F3CC->unk_01C0_0 && gUnknown_203F3CC->unk_01C1 != 0xFF) - { - RemoveScrollIndicatorArrowPair(gUnknown_203F3CC->unk_01C1); - gUnknown_203F3CC->unk_01C1 = 0xFF; - gUnknown_203F3CC->unk_01C0_0 = TRUE; - } -} - - -void MENews_AddScrollIndicatorArrowPair(void) -{ - if (gUnknown_203F3CC->unk_01C0_0) - { - gUnknown_203F3CC->unk_01C1 = AddScrollIndicatorArrowPair(&gUnknown_203F3CC->unk_0394, &gUnknown_203F3CC->unk_01C6); - gUnknown_203F3CC->unk_01C0_0 = FALSE; - } -} - -u32 MENews_GetInput(u16 input) -{ - if (gUnknown_203F3CC->unk_01C2_0) - { - sub_8146B58(); - return 0xFF; - } - switch (input) - { - case A_BUTTON: - return 0; - case B_BUTTON: - return 1; - case DPAD_UP: - if (gUnknown_203F3CC->unk_01C6 == 0) - return 0xFF; - if (gUnknown_203F3CC->unk_01C0_0) - return 0xFF; - gUnknown_203F3CC->unk_01C3_0 = FALSE; - break; - case DPAD_DOWN: - if (gUnknown_203F3CC->unk_01C6 == gUnknown_203F3CC->unk_01C4) - return 0xFF; - if (gUnknown_203F3CC->unk_01C0_0) - return 0xFF; - gUnknown_203F3CC->unk_01C3_0 = TRUE; - break; - default: - return 0xFF; - } - gUnknown_203F3CC->unk_01C2_0 = TRUE; - gUnknown_203F3CC->unk_01C2_1 = 2; - gUnknown_203F3CC->unk_01C3_1 = 0; - if (gUnknown_203F3CC->unk_01C3_0 == FALSE) - return 2; - else - return 3; -} - -void sub_8146980(void) -{ - u8 i = 0; - memcpy(gUnknown_203F3CC->unk_01CE, gUnknown_203F3CC->unk_0000.unk_04, 40); - gUnknown_203F3CC->unk_01CE[40] = EOS; - for (; i < 10; ++i) - { - memcpy(gUnknown_203F3CC->unk_01F7[i], gUnknown_203F3CC->unk_0000.unk_2C[i], 40); - gUnknown_203F3CC->unk_01F7[i][40] = EOS; - if (i > 7 && gUnknown_203F3CC->unk_01F7[i][0] != EOS) - ++gUnknown_203F3CC->unk_01C4; - } - gUnknown_203F3CC->unk_0394 = gUnknown_8468050; - gUnknown_203F3CC->unk_0394.fullyDownThreshold = gUnknown_203F3CC->unk_01C4; -} - -void sub_8146A30(void) -{ - u8 i = 0; - s32 x; - PutWindowTilemap(gUnknown_203F3CC->unk_01C8[0]); - PutWindowTilemap(gUnknown_203F3CC->unk_01C8[1]); - FillWindowPixelBuffer(gUnknown_203F3CC->unk_01C8[0], 0); - FillWindowPixelBuffer(gUnknown_203F3CC->unk_01C8[1], 0); - x = (0xe0 - GetStringWidth(3, gUnknown_203F3CC->unk_01CE, GetFontAttribute(3, 2))) / 2; - if (x < 0) - x = 0; - AddTextPrinterParameterized3(gUnknown_203F3CC->unk_01C8[0], 3, x, 6, gUnknown_8468038[gUnknown_203F3CC->unk_01BC->textPal1], 0, gUnknown_203F3CC->unk_01CE); - for (; i < 10; ++i) - { - AddTextPrinterParameterized3(gUnknown_203F3CC->unk_01C8[1], 3, 0, 16 * i + 2, gUnknown_8468038[gUnknown_203F3CC->unk_01BC->textPal2], 0, gUnknown_203F3CC->unk_01F7[i]); - } - CopyWindowToVram(gUnknown_203F3CC->unk_01C8[0], 3); - CopyWindowToVram(gUnknown_203F3CC->unk_01C8[1], 3); -} - -void sub_8146B58(void) -{ - u16 r4 = gUnknown_203F3CC->unk_01C2_1; - r4 <<= 8; - if (gUnknown_203F3CC->unk_01C3_0) - { - ChangeBgY(2, r4, 1); - ChangeBgY(3, r4, 1); - } - else - { - ChangeBgY(2, r4, 2); - ChangeBgY(3, r4, 2); - } - gUnknown_203F3CC->unk_01C3_1 += gUnknown_203F3CC->unk_01C2_1; - if (gUnknown_203F3CC->unk_01C3_1 > 15) - { - if (gUnknown_203F3CC->unk_01C3_0) - ++gUnknown_203F3CC->unk_01C6; - else - --gUnknown_203F3CC->unk_01C6; - gUnknown_203F3CC->unk_01C2_0 = FALSE; - gUnknown_203F3CC->unk_01C3_1 = 0; - } -} diff --git a/src/mevent_client.c b/src/mevent_client.c index 4da0b4bc1..d7eff1ec6 100644 --- a/src/mevent_client.c +++ b/src/mevent_client.c @@ -195,15 +195,16 @@ static u32 client_mainseq_4(struct mevent_client * svr) mevent_client_send_word(svr, 0x13, svr->param); break; case 10: - sub_8143F68(svr->recvBuffer); + OverwriteSavedWonderCardWithReceivedCard(svr->recvBuffer); break; case 9: - if (!sub_8143EF4(svr->recvBuffer)) + if (!MEvent_HaveAlreadyReceivedWonderNews(svr->recvBuffer)) { - sub_8143DC8(svr->recvBuffer); + OverwriteSavedWonderNewsWithReceivedNews(svr->recvBuffer); mevent_client_send_word(svr, 0x13, 0); } else + // Other trainer already has news mevent_client_send_word(svr, 0x13, 1); break; case 15: @@ -211,7 +212,7 @@ static u32 client_mainseq_4(struct mevent_client * svr) svr->flag = 0; break; case 16: - sub_8144254(svr->recvBuffer); + MEvent_ReceiveDistributionMon(svr->recvBuffer); break; case 17: MEventSetRamScript(svr->recvBuffer, 1000); diff --git a/src/mevent_server.c b/src/mevent_server.c index bebd69fe3..3b1762540 100644 --- a/src/mevent_server.c +++ b/src/mevent_server.c @@ -176,7 +176,7 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr) case 9: AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 408); ptr = mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord); - svr->param = sub_8144434(ptr, svr->mevent_unk1442cc, ptr); + svr->param = MEvent_CanPlayerReceiveDistributionMon(ptr, svr->mevent_unk1442cc, ptr); break; case 10: AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 415); @@ -247,7 +247,7 @@ static u32 common_mainseq_4(struct mevent_srv_common * svr) case 26: AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 506); memcpy(svr->card, GetSavedWonderCard(), 332); - sub_814410C(svr->card); + MEvent_WonderCardResetUnk08_6(svr->card); break; case 27: AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 512); diff --git a/src/mevent_show_card.c b/src/mevent_show_card.c new file mode 100644 index 000000000..3eeafa4b5 --- /dev/null +++ b/src/mevent_show_card.c @@ -0,0 +1,459 @@ +#include "global.h" +#include "constants/species.h" +#include "bg.h" +#include "gpu_regs.h" +#include "palette.h" +#include "decompress.h" +#include "malloc.h" +#include "menu.h" +#include "new_menu_helpers.h" +#include "pokemon_icon.h" +#include "mystery_gift_menu.h" +#include "menu_indicators.h" +#include "string_util.h" +#include "link_rfu.h" +#include "mevent.h" +#include "battle_anim.h" + +struct MEventScreenMgr_02DC +{ + u8 nDigits; + u8 nameTxt[41]; + u8 numberTxt[4]; +}; + +struct MEventScreenMgr +{ + /*0000*/ struct MEWonderCardData wonderCard; + /*014c*/ struct MEventBuffer_3430_Sub buff3430Sub; + /*0170*/ const struct UnkStruct_8467FB8 * bgSpec; + /*0174*/ u8 state; + /*0175*/ u8 recordIdx; + /*0176*/ u16 windowIds[3]; + /*017C*/ u8 monIconId; + /*017D*/ u8 cardIconAndShadowSprites[7][2]; + /*018B*/ u8 title[41]; + /*01B4*/ u8 subtitle[41]; + /*01DD*/ u8 unk_01DD[7]; + /*01E4*/ u8 mainMessageLines[4][41]; + /*0288*/ u8 instructionsLine1[41]; + /*02B1*/ u8 instructionsLine2[41]; + /*02DC*/ struct MEventScreenMgr_02DC recordStrings[8]; + /*045C*/ u8 buffer_045C[0x1000]; +}; + +static EWRAM_DATA struct MEventScreenMgr * sMEventScreenData = NULL; + +static void sub_8145A98(void); +static void sub_8145D18(u8 whichWindow); +static void sub_8146060(void); +static void sub_81461D8(void); + +static const u8 gUnknown_8467068[][3] = { + {0, 2, 3}, + {0, 1, 2} +}; + +static const u8 ALIGNED(4) sTextYCoords[3] = {7, 4, 7}; + +static const struct WindowTemplate sWindowTemplates[] = { + { + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 1, + .width = 25, + .height = 4, + .paletteNum = 15, + .baseBlock = 0x29c}, + { + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 6, + .width = 28, + .height = 8, + .paletteNum = 15, + .baseBlock = 0x1bc}, + { + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 14, + .width = 28, + .height = 5, + .paletteNum = 15, + .baseBlock = 0x130} +}; + +static const u16 gCard0Pal[] = INCBIN_U16("data/graphics/mevent/pal_46708C.gbapal"); +const u16 gCard1Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670AC.gbapal"); +const u16 gCard2Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670CC.gbapal"); +const u16 gCard3Pal[] = INCBIN_U16("data/graphics/mevent/pal_4670EC.gbapal"); +const u16 gCard4Pal[] = INCBIN_U16("data/graphics/mevent/pal_46710C.gbapal"); +const u16 gCard5Pal[] = INCBIN_U16("data/graphics/mevent/pal_46712C.gbapal"); +static const u16 gCard6Pal[] = INCBIN_U16("data/graphics/mevent/pal_46714C.gbapal"); +static const u16 gCard7Pal[] = INCBIN_U16("data/graphics/mevent/pal_46716C.gbapal"); +static const u8 sCard0Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46718C.4bpp.lz"); +static const u8 sCard0Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467288.bin.lz"); +static const u8 sCard1Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46737C.4bpp.lz"); +static const u8 sCard1Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467470.bin.lz"); +static const u8 sCard2Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467558.4bpp.lz"); +static const u8 sCard2Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46762C.bin.lz"); +static const u8 sCard6Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467700.4bpp.lz"); +static const u8 sCard6Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467934.bin.lz"); +static const u8 sCard7Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_467A7C.4bpp.lz"); +static const u8 sCard7Map[] = INCBIN_U8("data/graphics/mevent/tilemap_467CAC.bin.lz"); +static const u16 gUnknown_8467DF4[] = INCBIN_U16("data/graphics/mevent/pal_467DF4.gbapal"); +static const u16 gUnknown_8467E14[] = INCBIN_U16("data/graphics/mevent/pal_467E14.gbapal"); +static const u16 gUnknown_8467E34[] = INCBIN_U16("data/graphics/mevent/pal_467E34.gbapal"); +static const u16 gUnknown_8467E54[] = INCBIN_U16("data/graphics/mevent/pal_467E54.gbapal"); +static const u16 gUnknown_8467E74[] = INCBIN_U16("data/graphics/mevent/pal_467E74.gbapal"); +static const u16 gUnknown_8467E94[] = INCBIN_U16("data/graphics/mevent/pal_467E94.gbapal"); +static const u16 gUnknown_8467EB4[] = INCBIN_U16("data/graphics/mevent/pal_467EB4.gbapal"); +static const u16 gUnknown_8467ED4[] = INCBIN_U16("data/graphics/mevent/pal_467ED4.gbapal"); +static const u32 gUnknown_8467EF4[] = INCBIN_U32("data/graphics/mevent/gfx_467EF4.4bpp.lz"); + +static const struct CompressedSpriteSheet sShadowSpriteSheet = { + gUnknown_8467EF4, 0x100, 0x8000 +}; + +static const struct SpritePalette sShadowSpritePalettes[] = { + {gUnknown_8467DF4, 0x8000}, + {gUnknown_8467E14, 0x8000}, + {gUnknown_8467E34, 0x8000}, + {gUnknown_8467E54, 0x8000}, + {gUnknown_8467E74, 0x8000}, + {gUnknown_8467E94, 0x8000}, + {gUnknown_8467EB4, 0x8000}, + {gUnknown_8467ED4, 0x8000} +}; + +static const struct SpriteTemplate sShadowSpriteTemplate = { + 0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy +}; + +static const struct UnkStruct_8467FB8 sCardGfxPtrs[8] = { + {1, 0, 0, 0, sCard0Gfx, sCard0Map, gCard0Pal}, + {1, 0, 0, 1, sCard1Gfx, sCard1Map, gCard1Pal}, + {1, 0, 0, 2, sCard2Gfx, sCard2Map, gCard2Pal}, + {1, 0, 0, 3, sCard2Gfx, sCard2Map, gCard3Pal}, + {1, 0, 0, 4, sCard2Gfx, sCard2Map, gCard4Pal}, + {1, 0, 0, 5, sCard2Gfx, sCard2Map, gCard5Pal}, + {1, 0, 0, 6, sCard6Gfx, sCard6Map, gCard6Pal}, + {1, 0, 0, 7, sCard7Gfx, sCard7Map, gCard7Pal} +}; + +bool32 InitWonderCardResources(struct MEWonderCardData * card, struct MEventBuffer_3430_Sub * b3430sub) +{ + if (card == NULL || b3430sub == NULL) + return FALSE; + sMEventScreenData = AllocZeroed(sizeof(struct MEventScreenMgr)); + if (sMEventScreenData == NULL) + return FALSE; + sMEventScreenData->wonderCard = *card; + sMEventScreenData->buff3430Sub = *b3430sub; + if (sMEventScreenData->wonderCard.unk_08_2 >= NELEMS(sCardGfxPtrs)) + sMEventScreenData->wonderCard.unk_08_2 = 0; + if (sMEventScreenData->wonderCard.unk_08_0 >= NELEMS(sTextYCoords)) + sMEventScreenData->wonderCard.unk_08_0 = 0; + if (sMEventScreenData->wonderCard.recvMonCapacity > NELEMS(sMEventScreenData->cardIconAndShadowSprites)) + sMEventScreenData->wonderCard.recvMonCapacity = 0; + sMEventScreenData->bgSpec = &sCardGfxPtrs[sMEventScreenData->wonderCard.unk_08_2]; + return TRUE; +} + +void DestroyWonderCardResources(void) +{ + if (sMEventScreenData != NULL) + { + *sMEventScreenData = (struct MEventScreenMgr){}; + Free(sMEventScreenData); + sMEventScreenData = NULL; + } +} + +s32 FadeToWonderCardMenu(void) +{ + if (sMEventScreenData == NULL) + return -1; + switch(sMEventScreenData->state) + { + case 0: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + break; + case 1: + if (UpdatePaletteFade()) + return 0; + break; + case 2: + FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(1); + CopyBgTilemapBufferToVram(2); + DecompressAndCopyTileDataToVram(2, sMEventScreenData->bgSpec->tiles, 0, 0x008, 0); + sMEventScreenData->windowIds[0] = AddWindow(&sWindowTemplates[0]); + sMEventScreenData->windowIds[1] = AddWindow(&sWindowTemplates[1]); + sMEventScreenData->windowIds[2] = AddWindow(&sWindowTemplates[2]); + break; + case 3: + if (FreeTempTileDataBuffersIfPossible()) + return 0; + gPaletteFade.bufferTransferDisabled = TRUE; + LoadPalette(sMEventScreenData->bgSpec->pal, 0x10, 0x20); + LZ77UnCompWram(sMEventScreenData->bgSpec->map, sMEventScreenData->buffer_045C); + CopyRectToBgTilemapBufferRect(2, sMEventScreenData->buffer_045C, 0, 0, 30, 20, 0, 0, 30, 20, 1, 0x008, 0); + CopyBgTilemapBufferToVram(2); + break; + case 4: + sub_8145A98(); + break; + case 5: + sub_8145D18(0); + sub_8145D18(1); + sub_8145D18(2); + CopyBgTilemapBufferToVram(1); + break; + case 6: + LoadMonIconPalettes(); + break; + case 7: + ShowBg(1); + ShowBg(2); + gPaletteFade.bufferTransferDisabled = FALSE; + sub_8146060(); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK); + UpdatePaletteFade(); + break; + default: + if (UpdatePaletteFade()) + return 0; + sMEventScreenData->state = 0; + return 1; + } + ++sMEventScreenData->state; + return 0; +} + +s32 FadeOutFromWonderCard(bool32 flag) +{ + if (sMEventScreenData == NULL) + return -1; + switch (sMEventScreenData->state) + { + case 0: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + break; + case 1: + if (UpdatePaletteFade()) + return 0; + break; + case 2: + FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(1); + CopyBgTilemapBufferToVram(2); + break; + case 3: + HideBg(1); + HideBg(2); + RemoveWindow(sMEventScreenData->windowIds[2]); + RemoveWindow(sMEventScreenData->windowIds[1]); + RemoveWindow(sMEventScreenData->windowIds[0]); + break; + case 4: + sub_81461D8(); + FreeMonIconPalettes(); + break; + case 5: + PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag); + break; + case 6: + CopyBgTilemapBufferToVram(0); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK); + break; + default: + if (UpdatePaletteFade()) + return 0; + sMEventScreenData->state = 0; + return 1; + } + ++sMEventScreenData->state; + return 0; +} + +static void sub_8145A98(void) +{ + u16 i = 0; + u16 r6; + u16 sp0[3] = {0, 0, 0}; + + memcpy(sMEventScreenData->title, sMEventScreenData->wonderCard.unk_0A, 40); + sMEventScreenData->title[40] = EOS; + memcpy(sMEventScreenData->subtitle, sMEventScreenData->wonderCard.unk_32, 40); + sMEventScreenData->subtitle[40] = EOS; + if (sMEventScreenData->wonderCard.unk_04 > 999999) + sMEventScreenData->wonderCard.unk_04 = 999999; + ConvertIntToDecimalStringN(sMEventScreenData->unk_01DD, sMEventScreenData->wonderCard.unk_04, STR_CONV_MODE_LEFT_ALIGN, 6); + for (i = 0; i < 4; i++) + { + memcpy(sMEventScreenData->mainMessageLines[i], sMEventScreenData->wonderCard.unk_5A[i], 40); + sMEventScreenData->mainMessageLines[i][40] = EOS; + } + memcpy(sMEventScreenData->instructionsLine1, sMEventScreenData->wonderCard.unk_FA, 40); + sMEventScreenData->instructionsLine1[40] = EOS; + switch (sMEventScreenData->wonderCard.unk_08_0) + { + case 0: + memcpy(sMEventScreenData->instructionsLine2, sMEventScreenData->wonderCard.unk_122, 40); + sMEventScreenData->instructionsLine2[40] = EOS; + break; + case 1: + sMEventScreenData->instructionsLine2[00] = EOS; + break; + case 2: + sMEventScreenData->instructionsLine2[00] = EOS; + sp0[0] = sMEventScreenData->buff3430Sub.linkWins < 999 ? sMEventScreenData->buff3430Sub.linkWins : 999; + sp0[1] = sMEventScreenData->buff3430Sub.linkLosses < 999 ? sMEventScreenData->buff3430Sub.linkLosses : 999; + sp0[2] = sMEventScreenData->buff3430Sub.linkTrades < 999 ? sMEventScreenData->buff3430Sub.linkTrades : 999; + for (i = 0; i < 8; i++) + { + memset(sMEventScreenData->recordStrings[i].numberTxt, EOS, 4); + memset(sMEventScreenData->recordStrings[i].nameTxt, EOS, 41); + } + for (i = 0, r6 = 0; i < 40; i++) + { + if (sMEventScreenData->wonderCard.unk_122[i] != CHAR_SPECIAL_F7) + { + sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].nameTxt[r6] = sMEventScreenData->wonderCard.unk_122[i]; + r6++; + } + else + { + u8 r3 = sMEventScreenData->wonderCard.unk_122[i + 1]; + if (r3 > 2) + { + i += 2; + } + else + { + ConvertIntToDecimalStringN(sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].numberTxt, sp0[r3], STR_CONV_MODE_LEADING_ZEROS, 3); + sMEventScreenData->recordStrings[sMEventScreenData->recordIdx].nDigits = sMEventScreenData->wonderCard.unk_122[i + 2]; + sMEventScreenData->recordIdx++; + if (sMEventScreenData->recordIdx > 7) + break; + r6 = 0; + i += 2; + } + } + } + } +} + +static void sub_8145D18(u8 whichWindow) +{ + s8 sp0C = 0; + s32 windowId = sMEventScreenData->windowIds[whichWindow]; + PutWindowTilemap(windowId); + FillWindowPixelBuffer(windowId, 0); + switch (whichWindow) + { + case 0: + { + s32 x; + AddTextPrinterParameterized3(windowId, 3, 0, 1, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->title); + x = 160 - GetStringWidth(3, sMEventScreenData->subtitle, GetFontAttribute(3, 2)); + if (x < 0) + x = 0; + AddTextPrinterParameterized3(windowId, 3, x, 17, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->subtitle); + if (sMEventScreenData->wonderCard.unk_04 != 0) + { + AddTextPrinterParameterized3(windowId, 2, 166, 17, gUnknown_8467068[sMEventScreenData->bgSpec->textPal1], 0, sMEventScreenData->unk_01DD); + } + break; + } + case 1: + for (; sp0C < 4; sp0C++) + { + AddTextPrinterParameterized3(windowId, 3, 0, 16 * sp0C + 2, gUnknown_8467068[sMEventScreenData->bgSpec->textPal2], 0, sMEventScreenData->mainMessageLines[sp0C]); + } + break; + case 2: + AddTextPrinterParameterized3(windowId, 3, 0, sTextYCoords[sMEventScreenData->wonderCard.unk_08_0], gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->instructionsLine1); + if (sMEventScreenData->wonderCard.unk_08_0 != 2) + { + AddTextPrinterParameterized3(windowId, 3, 0, 16 + sTextYCoords[sMEventScreenData->wonderCard.unk_08_0], gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->instructionsLine2); + } + else + { + s32 x = 0; + s32 y = sTextYCoords[sMEventScreenData->wonderCard.unk_08_0] + 16; + s32 spacing = GetFontAttribute(3, 2); + for (; sp0C < sMEventScreenData->recordIdx; sp0C++) + { + AddTextPrinterParameterized3(windowId, 3, x, y, gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->recordStrings[sp0C].nameTxt); + if (sMEventScreenData->recordStrings[sp0C].numberTxt[0] != EOS) + { + x += GetStringWidth(3, sMEventScreenData->recordStrings[sp0C].nameTxt, spacing); + AddTextPrinterParameterized3(windowId, 2, x, y, gUnknown_8467068[sMEventScreenData->bgSpec->textPal3], 0, sMEventScreenData->recordStrings[sp0C].numberTxt); + x += GetStringWidth(3, sMEventScreenData->recordStrings[sp0C].numberTxt, spacing) + sMEventScreenData->recordStrings[sp0C].nDigits; + } + } + } + break; + } + CopyWindowToVram(windowId, 3); +} + +static void sub_8146060(void) +{ + u8 r7 = 0; + sMEventScreenData->monIconId = 0xFF; + if (sMEventScreenData->buff3430Sub.unk_06 != SPECIES_NONE) + { + sMEventScreenData->monIconId = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(sMEventScreenData->buff3430Sub.unk_06), SpriteCallbackDummy, 0xDC, 0x14, 0, FALSE); + gSprites[sMEventScreenData->monIconId].oam.priority = 2; + } + if (sMEventScreenData->wonderCard.recvMonCapacity != 0 && sMEventScreenData->wonderCard.unk_08_0 == 1) + { + LoadCompressedSpriteSheetUsingHeap(&sShadowSpriteSheet); + LoadSpritePalette(&sShadowSpritePalettes[sMEventScreenData->bgSpec->index]); + for (; r7 < sMEventScreenData->wonderCard.recvMonCapacity; r7++) + { + sMEventScreenData->cardIconAndShadowSprites[r7][0] = 0xFF; + sMEventScreenData->cardIconAndShadowSprites[r7][1] = 0xFF; + sMEventScreenData->cardIconAndShadowSprites[r7][0] = CreateSprite(&sShadowSpriteTemplate, 0xd8 - 32 * r7, 0x90, 8); + if (sMEventScreenData->buff3430Sub.distributedMons[0][r7] != 0) + { + sMEventScreenData->cardIconAndShadowSprites[r7][1] = CreateMonIcon_HandleDeoxys(MailSpeciesToIconSpecies(sMEventScreenData->buff3430Sub.distributedMons[0][r7]), SpriteCallbackDummy, 0xd8 - 32 * r7, 0x88, 0, 0); + gSprites[sMEventScreenData->cardIconAndShadowSprites[r7][1]].oam.priority = 2; + } + } + } +} + +static void sub_81461D8(void) +{ + u8 r6 = 0; + if (sMEventScreenData->monIconId != 0xFF) + DestroyMonIcon(&gSprites[sMEventScreenData->monIconId]); + if (sMEventScreenData->wonderCard.recvMonCapacity != 0 && sMEventScreenData->wonderCard.unk_08_0 == 1) + { + for (; r6 < sMEventScreenData->wonderCard.recvMonCapacity; r6++) + { + if (sMEventScreenData->cardIconAndShadowSprites[r6][0] != 0xFF) + { + DestroySprite(&gSprites[sMEventScreenData->cardIconAndShadowSprites[r6][0]]); + // This might be a typo. Uncomment the next line, and comment the one that follows, to get the presumed intended behavior. + // if (sMEventScreenData->cardIconAndShadowSprites[r6][1] != 0xFF) + if (sMEventScreenData->cardIconAndShadowSprites[r6][0] != 0xFF) + { + DestroyMonIcon(&gSprites[sMEventScreenData->cardIconAndShadowSprites[r6][1]]); + } + } + } + FreeSpriteTilesByTag(0x8000); + FreeSpritePaletteByTag(0x8000); + } +} diff --git a/src/mevent_show_news.c b/src/mevent_show_news.c new file mode 100644 index 000000000..44b19b130 --- /dev/null +++ b/src/mevent_show_news.c @@ -0,0 +1,357 @@ +#include "global.h" +#include "gflib.h" +#include "menu_indicators.h" +#include "new_menu_helpers.h" +#include "mevent.h" +#include "mystery_gift_menu.h" +#include "menu.h" +#include "link_rfu.h" + +struct UnkStruct_203F3CC +{ + /*0000*/ struct MEWonderNewsData wonderNews; + /*01bc*/ const struct UnkStruct_8467FB8 * bgSpec; + /*01c0*/ u8 verticalScrollDisabled:1; + u8 state:7; + /*01c1*/ u8 menuIndicatorsId; + /*01c2*/ u8 unk_01C2_0:1; + u8 unk_01C2_1:7; + /*01c3*/ u8 scrollDirection:1; + u8 unk_01C3_1:7; + /*01c4*/ u16 numMails; + /*01c6*/ u16 scrollOffset; + /*01c8*/ u16 windowIds[2]; + /*01cc*/ u8 filler_01CC[2]; + /*01ce*/ u8 title[41]; + /*01f7*/ u8 messages[10][41]; + /*0394*/ struct ScrollArrowsTemplate scrollArrowsTemplate; + /*03a4*/ u8 buffer_03A4[0x1000]; +}; + +static EWRAM_DATA struct UnkStruct_203F3CC * sWork = NULL; + +static void sub_8146980(void); +static void sub_8146A30(void); +static void sub_8146B58(void); + +static const u8 sTextPals[][3] = { + {0, 2, 3}, + {0, 1, 2} +}; +static const struct WindowTemplate gUnknown_8468040[] = { + {0, 1, 0, 28, 3, 15, 0x000}, + {2, 1, 3, 28, 20, 15, 0x000} +}; +static const struct ScrollArrowsTemplate sScrollArrowsTemplate = { + 0x02, 0xe8, 0x18, 0x03, 0xe8, 0x98, + 0x0000, 0x0002, 0x1000, 0x1000, 0x0, +}; + +static const u16 sNews1Pal[] = INCBIN_U16("data/graphics/mevent/pal_468060.gbapal"); +static const u16 sNews6Pal[] = INCBIN_U16("data/graphics/mevent/pal_468080.gbapal"); +static const u16 sNews7Pal[] = INCBIN_U16("data/graphics/mevent/pal_4680A0.gbapal"); +static const u8 sNews0Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_4680C0.4bpp.lz"); +static const u8 sNews0Map[] = INCBIN_U8("data/graphics/mevent/tilemap_468140.bin.lz"); +static const u8 sNews1Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46821C.4bpp.lz"); +static const u8 sNews1Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46824C.bin.lz"); +static const u8 sNews2Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_46830C.4bpp.lz"); +static const u8 sNews2Map[] = INCBIN_U8("data/graphics/mevent/tilemap_46837C.bin.lz"); +static const u8 sNews6Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_468448.4bpp.lz"); +static const u8 sNews6Map[] = INCBIN_U8("data/graphics/mevent/tilemap_4684D8.bin.lz"); +static const u8 sNews7Gfx[] = INCBIN_U8("data/graphics/mevent/gfx_4685B4.4bpp.lz"); +static const u8 sNews7Map[] = INCBIN_U8("data/graphics/mevent/tilemap_468644.bin.lz"); + +static const struct UnkStruct_8467FB8 sBgSpecs[] = { + {1, 0, 0, 0, sNews0Gfx, sNews0Map, sNews1Pal}, + {1, 0, 0, 0, sNews1Gfx, sNews1Map, gCard1Pal}, + {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard2Pal}, + {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard3Pal}, + {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard4Pal}, + {1, 0, 0, 0, sNews2Gfx, sNews2Map, gCard5Pal}, + {1, 0, 0, 0, sNews6Gfx, sNews6Map, sNews6Pal}, + {1, 0, 0, 0, sNews7Gfx, sNews7Map, sNews7Pal} +}; + +bool32 InitWonderNewsResources(const struct MEWonderNewsData * news) +{ + if (news == NULL) + return FALSE; + sWork = AllocZeroed(sizeof(struct UnkStruct_203F3CC)); + if (sWork == NULL) + return FALSE; + sWork->wonderNews = *news; + if (sWork->wonderNews.unk_03 >= NELEMS(sBgSpecs)) + sWork->wonderNews.unk_03 = 0; + sWork->bgSpec = &sBgSpecs[sWork->wonderNews.unk_03]; + sWork->menuIndicatorsId = 0xFF; + return TRUE; +} + +void DestroyWonderNewsResources(void) +{ + if (sWork != NULL) + { + *sWork = (struct UnkStruct_203F3CC){}; + Free(sWork); + sWork = NULL; + } +} + +s32 FadeToWonderNewsMenu(void) +{ + if (sWork == NULL) + return -1; + + switch (sWork->state) + { + case 0: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + break; + case 1: + if (UpdatePaletteFade()) + return 0; + ChangeBgY(0, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgY(3, 0, 0); + SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 240)); + SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(26, 152)); + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); + break; + case 2: + FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 20); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(1); + CopyBgTilemapBufferToVram(2); + CopyBgTilemapBufferToVram(3); + DecompressAndCopyTileDataToVram(3, sWork->bgSpec->tiles, 0, 8, 0); + sWork->windowIds[0] = AddWindow(&gUnknown_8468040[0]); + sWork->windowIds[1] = AddWindow(&gUnknown_8468040[1]); + break; + case 3: + if (FreeTempTileDataBuffersIfPossible()) + return 0; + gPaletteFade.bufferTransferDisabled = TRUE; + LoadPalette(sWork->bgSpec->pal, 0x10, 0x20); + LZ77UnCompWram(sWork->bgSpec->map, sWork->buffer_03A4); + CopyRectToBgTilemapBufferRect(1, sWork->buffer_03A4, 0, 0, 30, 3, 0, 0, 30, 3, 1, 8, 0); + CopyRectToBgTilemapBufferRect(3, sWork->buffer_03A4, 0, 3, 30, 23, 0, 3, 30, 23, 1, 8, 0); + CopyBgTilemapBufferToVram(1); + CopyBgTilemapBufferToVram(3); + break; + case 4: + sub_8146980(); + break; + case 5: + sub_8146A30(); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(2); + break; + case 6: + ShowBg(1); + ShowBg(2); + ShowBg(3); + gPaletteFade.bufferTransferDisabled = FALSE; + sWork->menuIndicatorsId = AddScrollIndicatorArrowPair(&sWork->scrollArrowsTemplate, &sWork->scrollOffset); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK); + UpdatePaletteFade(); + break; + default: + if (UpdatePaletteFade()) + return 0; + sWork->state = 0; + return 1; + } + + ++sWork->state; + return 0; +} + +s32 FadeOutFromWonderNews(bool32 flag) +{ + if (sWork == NULL) + return -1; + switch (sWork->state) + { + case 0: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + break; + case 1: + if (UpdatePaletteFade()) + return 0; + ChangeBgY(2, 0, 0); + SetGpuReg(REG_OFFSET_WIN0H, 0); + SetGpuReg(REG_OFFSET_WIN0V, 0); + SetGpuReg(REG_OFFSET_WININ, 0); + SetGpuReg(REG_OFFSET_WINOUT, 0); + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); + break; + case 2: + FillBgTilemapBufferRect_Palette0(0, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(1, 0x000, 0, 0, 30, 20); + FillBgTilemapBufferRect_Palette0(2, 0x000, 0, 0, 30, 24); + FillBgTilemapBufferRect_Palette0(3, 0x000, 0, 0, 30, 24); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(1); + CopyBgTilemapBufferToVram(2); + CopyBgTilemapBufferToVram(3); + break; + case 3: + HideBg(1); + HideBg(2); + RemoveWindow(sWork->windowIds[1]); + RemoveWindow(sWork->windowIds[0]); + break; + case 4: + ChangeBgY(2, 0, 0); + ChangeBgY(3, 0, 0); + if (sWork->menuIndicatorsId != 0xFF) + { + RemoveScrollIndicatorArrowPair(sWork->menuIndicatorsId); + sWork->menuIndicatorsId = 0xFF; + } + break; + case 5: + PrintMysteryGiftOrEReaderTopMenu(gGiftIsFromEReader, flag); + break; + case 6: + MG_DrawCheckerboardPattern(); + CopyBgTilemapBufferToVram(0); + CopyBgTilemapBufferToVram(3); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK); + break; + default: + if (UpdatePaletteFade()) + return 0; + sWork->state = 0; + return 1; + } + ++sWork->state; + return 0; +} + +void MENews_RemoveScrollIndicatorArrowPair(void) +{ + if (!sWork->verticalScrollDisabled && sWork->menuIndicatorsId != 0xFF) + { + RemoveScrollIndicatorArrowPair(sWork->menuIndicatorsId); + sWork->menuIndicatorsId = 0xFF; + sWork->verticalScrollDisabled = TRUE; + } +} + + +void MENews_AddScrollIndicatorArrowPair(void) +{ + if (sWork->verticalScrollDisabled) + { + sWork->menuIndicatorsId = AddScrollIndicatorArrowPair(&sWork->scrollArrowsTemplate, &sWork->scrollOffset); + sWork->verticalScrollDisabled = FALSE; + } +} + +u32 MENews_GetInput(u16 input) +{ + if (sWork->unk_01C2_0) + { + sub_8146B58(); + return 0xFF; + } + switch (input) + { + case A_BUTTON: + return 0; + case B_BUTTON: + return 1; + case DPAD_UP: + if (sWork->scrollOffset == 0) + return 0xFF; + if (sWork->verticalScrollDisabled) + return 0xFF; + sWork->scrollDirection = FALSE; + break; + case DPAD_DOWN: + if (sWork->scrollOffset == sWork->numMails) + return 0xFF; + if (sWork->verticalScrollDisabled) + return 0xFF; + sWork->scrollDirection = TRUE; + break; + default: + return 0xFF; + } + sWork->unk_01C2_0 = TRUE; + sWork->unk_01C2_1 = 2; + sWork->unk_01C3_1 = 0; + if (sWork->scrollDirection == FALSE) + return 2; + else + return 3; +} + +static void sub_8146980(void) +{ + u8 i = 0; + memcpy(sWork->title, sWork->wonderNews.unk_04, 40); + sWork->title[40] = EOS; + for (; i < 10; ++i) + { + memcpy(sWork->messages[i], sWork->wonderNews.unk_2C[i], 40); + sWork->messages[i][40] = EOS; + if (i > 7 && sWork->messages[i][0] != EOS) + ++sWork->numMails; + } + sWork->scrollArrowsTemplate = sScrollArrowsTemplate; + sWork->scrollArrowsTemplate.fullyDownThreshold = sWork->numMails; +} + +static void sub_8146A30(void) +{ + u8 i = 0; + s32 x; + PutWindowTilemap(sWork->windowIds[0]); + PutWindowTilemap(sWork->windowIds[1]); + FillWindowPixelBuffer(sWork->windowIds[0], 0); + FillWindowPixelBuffer(sWork->windowIds[1], 0); + x = (0xe0 - GetStringWidth(3, sWork->title, GetFontAttribute(3, 2))) / 2; + if (x < 0) + x = 0; + AddTextPrinterParameterized3(sWork->windowIds[0], 3, x, 6, sTextPals[sWork->bgSpec->textPal1], 0, sWork->title); + for (; i < 10; ++i) + { + AddTextPrinterParameterized3(sWork->windowIds[1], 3, 0, 16 * i + 2, sTextPals[sWork->bgSpec->textPal2], 0, sWork->messages[i]); + } + CopyWindowToVram(sWork->windowIds[0], 3); + CopyWindowToVram(sWork->windowIds[1], 3); +} + +static void sub_8146B58(void) +{ + u16 r4 = sWork->unk_01C2_1; + r4 <<= 8; + if (sWork->scrollDirection) + { + ChangeBgY(2, r4, 1); + ChangeBgY(3, r4, 1); + } + else + { + ChangeBgY(2, r4, 2); + ChangeBgY(3, r4, 2); + } + sWork->unk_01C3_1 += sWork->unk_01C2_1; + if (sWork->unk_01C3_1 > 15) + { + if (sWork->scrollDirection) + ++sWork->scrollOffset; + else + --sWork->scrollOffset; + sWork->unk_01C2_0 = FALSE; + sWork->unk_01C3_1 = 0; + } +} diff --git a/src/unk_815F138.c b/src/minigame_countdown.c index 8aa776bc9..d100caea1 100644 --- a/src/unk_815F138.c +++ b/src/minigame_countdown.c @@ -5,72 +5,83 @@ #include "trig.h" #include "constants/songs.h" -void sub_815F1AC(u8 taskId); -bool32 sub_815F2AC(u8 spriteId); -void sub_815F3E0(u8 spriteId1, u8 spriteId2, u8 spriteId3); -bool32 sub_815F444(u8 spriteId); -void sub_815F470(struct Sprite * sprite); -void sub_815F564(u16 tilesTag, u16 palTag); -u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority); -void sub_815F610(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p); +static void Task_MinigameCountdown(u8 taskId); +static bool32 RunMinigameCountdownDigitsAnim(u8 spriteId); +static void StartStartGraphic(u8 spriteId1, u8 spriteId2, u8 spriteId3); +static bool32 IsStartGraphicAnimRunning(u8 spriteId); +static void SpriteCB_Start(struct Sprite * sprite); +static void Load321StartGfx(u16 tilesTag, u16 palTag); +static u8 CreateNumberSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority); +static void CreateStartSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p); -void sub_815F138(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority) +#define tState data[0] +#define tTilesTag data[2] +#define tPalTag data[3] +#define tX data[4] +#define tY data[5] +#define tSubpriority data[6] +#define tSpriteId1 data[7] +#define tSpriteId2 data[8] +#define tSpriteId3 data[9] + +void StartMinigameCountdown(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority) { - u8 taskId = CreateTask(sub_815F1AC, 80); - gTasks[taskId].data[2] = tilesTag; - gTasks[taskId].data[3] = palTag; - gTasks[taskId].data[4] = x; - gTasks[taskId].data[5] = y; - gTasks[taskId].data[6] = subpriority; + u8 taskId = CreateTask(Task_MinigameCountdown, 80); + gTasks[taskId].tTilesTag = tilesTag; + gTasks[taskId].tPalTag = palTag; + gTasks[taskId].tX = x; + gTasks[taskId].tY = y; + gTasks[taskId].tSubpriority = subpriority; } -bool8 sub_815F198(void) +bool8 IsMinigameCountdownRunning(void) { - return FuncIsActiveTask(sub_815F1AC); + return FuncIsActiveTask(Task_MinigameCountdown); } -void sub_815F1AC(u8 taskId) +static void Task_MinigameCountdown(u8 taskId) { s16 * data = gTasks[taskId].data; - switch (data[0]) + switch (tState) { case 0: - sub_815F564(data[2], data[3]); - data[7] = sub_815F5BC(data[2], data[3], data[4], data[5], data[6]); - sub_815F610(data[2], data[3], data[4], data[5], data[6], &data[8], &data[9]); - data[0]++; + Load321StartGfx(tTilesTag, tPalTag); + tSpriteId1 = CreateNumberSprite(tTilesTag, tPalTag, tX, tY, tSubpriority); + CreateStartSprite(tTilesTag, tPalTag, tX, tY, tSubpriority, &tSpriteId2, &tSpriteId3); + tState++; break; case 1: - if (!sub_815F2AC(data[7])) + if (!RunMinigameCountdownDigitsAnim(tSpriteId1)) { - sub_815F3E0(data[7], data[8], data[9]); - FreeSpriteOamMatrix(&gSprites[data[7]]); - DestroySprite(&gSprites[data[7]]); - data[0]++; + StartStartGraphic(tSpriteId1, tSpriteId2, tSpriteId3); + FreeSpriteOamMatrix(&gSprites[tSpriteId1]); + DestroySprite(&gSprites[tSpriteId1]); + tState++; } break; case 2: - if (!sub_815F444(data[8])) + if (!IsStartGraphicAnimRunning(tSpriteId2)) { - DestroySprite(&gSprites[data[8]]); - DestroySprite(&gSprites[data[9]]); - FreeSpriteTilesByTag(data[2]); - FreeSpritePaletteByTag(data[3]); + DestroySprite(&gSprites[tSpriteId2]); + DestroySprite(&gSprites[tSpriteId3]); + FreeSpriteTilesByTag(tTilesTag); + FreeSpritePaletteByTag(tPalTag); DestroyTask(taskId); } break; } } -bool32 sub_815F2AC(u8 spriteId) +static bool32 RunMinigameCountdownDigitsAnim(u8 spriteId) { struct Sprite * sprite = &gSprites[spriteId]; switch (sprite->data[0]) { case 0: - sub_8007FFC(sprite, 0x800, 0x1A); + // some sort of affine transform; x transform disabled + obj_pos2_update_enable(sprite, 0x800, 0x1A); sprite->data[0]++; // fallthrough case 1: @@ -134,22 +145,22 @@ bool32 sub_815F2AC(u8 spriteId) return TRUE; } -void sub_815F3E0(u8 spriteId1, u8 spriteId2, u8 spriteId3) +static void StartStartGraphic(u8 spriteId1, u8 spriteId2, u8 spriteId3) { gSprites[spriteId2].pos2.y = -40; gSprites[spriteId3].pos2.y = -40; gSprites[spriteId2].invisible = FALSE; gSprites[spriteId3].invisible = FALSE; - gSprites[spriteId2].callback = sub_815F470; - gSprites[spriteId3].callback = sub_815F470; + gSprites[spriteId2].callback = SpriteCB_Start; + gSprites[spriteId3].callback = SpriteCB_Start; } -bool32 sub_815F444(u8 spriteId) +static bool32 IsStartGraphicAnimRunning(u8 spriteId) { - return gSprites[spriteId].callback == sub_815F470; + return gSprites[spriteId].callback == SpriteCB_Start; } -void sub_815F470(struct Sprite * sprite) +static void SpriteCB_Start(struct Sprite * sprite) { s16 * data = sprite->data; s32 y; @@ -200,103 +211,103 @@ void sub_815F470(struct Sprite * sprite) } } -const u16 gUnknown_847A328[] = INCBIN_U16("data/graphics/unk_847a348.gbapal"); -const u16 gUnknown_847A348[] = INCBIN_U16("data/graphics/unk_847a348.4bpp.lz"); +static const u16 sSpritePal_321Start[] = INCBIN_U16("data/graphics/unk_847a348.gbapal"); +static const u16 sSpriteSheet_321Start[] = INCBIN_U16("data/graphics/unk_847a348.4bpp.lz"); -void sub_815F564(u16 tilesTag, u16 palTag) +static void Load321StartGfx(u16 tilesTag, u16 palTag) { - struct CompressedSpriteSheet spriteSheet = {(const void *)gUnknown_847A348, 0xE00}; - struct SpritePalette spritePalette = {gUnknown_847A328}; + struct CompressedSpriteSheet spriteSheet = {(const void *)sSpriteSheet_321Start, 0xE00}; + struct SpritePalette spritePalette = {sSpritePal_321Start}; spriteSheet.tag = tilesTag; spritePalette.tag = palTag; LoadCompressedSpriteSheet(&spriteSheet); LoadSpritePalette(&spritePalette); } -const struct OamData gOamData_847A7AC = { +static const struct OamData sOamData_Numbers = { .affineMode = ST_OAM_AFFINE_DOUBLE, - .shape = ST_OAM_SQUARE, - .size = 2 + .shape = SPRITE_SHAPE(32x32), + .size = SPRITE_SIZE(32x32) }; -const struct OamData gOamData_847A7B4 = { +static const struct OamData sOamData_Start = { .affineMode = ST_OAM_AFFINE_OFF, - .shape = ST_OAM_H_RECTANGLE, - .size = 3 + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32) }; -const union AnimCmd gUnknown_847A7BC[] = { +static const union AnimCmd sAnim_Numbers_Three[] = { ANIMCMD_FRAME( 0, 1), ANIMCMD_END }; -const union AnimCmd gUnknown_847A7C4[] = { +static const union AnimCmd sAnim_Numbers_Two[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END }; -const union AnimCmd gUnknown_847A7CC[] = { +static const union AnimCmd sAnim_Numbers_One[] = { ANIMCMD_FRAME(32, 1), ANIMCMD_END }; -const union AnimCmd *const gUnknown_847A7D4[] = { - gUnknown_847A7BC, - gUnknown_847A7C4, - gUnknown_847A7CC +static const union AnimCmd *const sAnimTable_Numbers[] = { + sAnim_Numbers_Three, + sAnim_Numbers_Two, + sAnim_Numbers_One }; -const union AnimCmd gUnknown_847A7E0[] = { +static const union AnimCmd sAnim_StartLeft[] = { ANIMCMD_FRAME(48, 1), ANIMCMD_END }; -const union AnimCmd gUnknown_847A7E8[] = { +static const union AnimCmd sAnim_StartRight[] = { ANIMCMD_FRAME(80, 1), ANIMCMD_END }; -const union AnimCmd *const gUnknown_847A7F0[] = { - gUnknown_847A7E0, - gUnknown_847A7E8 +static const union AnimCmd *const sAnimTable_Start[] = { + sAnim_StartLeft, + sAnim_StartRight }; -const union AffineAnimCmd gUnknown_847A7F8[] = { +static const union AffineAnimCmd sAffineAnim_Numbers_0[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; -const union AffineAnimCmd gUnknown_847A808[] = { +static const union AffineAnimCmd sAffineAnim_Numbers_1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME( 0x10, -0x10, 0, 8), AFFINEANIMCMD_END }; -const union AffineAnimCmd gUnknown_847A820[] = { +static const union AffineAnimCmd sAffineAnim_Numbers_2[] = { AFFINEANIMCMD_FRAME(-0x12, 0x12, 0, 8), AFFINEANIMCMD_END }; -const union AffineAnimCmd gUnknown_847A830[] = { +static const union AffineAnimCmd sAffineAnim_Numbers_3[] = { AFFINEANIMCMD_FRAME( 0x6, -0x6, 0, 8), AFFINEANIMCMD_FRAME( -0x4, 0x4, 0, 8), AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; -const union AffineAnimCmd *const gUnknown_847A850[] = { - gUnknown_847A7F8, - gUnknown_847A808, - gUnknown_847A820, - gUnknown_847A830 +static const union AffineAnimCmd *const sAffineAnimTable_Numbers[] = { + sAffineAnim_Numbers_0, + sAffineAnim_Numbers_1, + sAffineAnim_Numbers_2, + sAffineAnim_Numbers_3 }; -u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority) +static u8 CreateNumberSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority) { struct SpriteTemplate spriteTemplate = { - .oam = &gOamData_847A7AC, - .anims = gUnknown_847A7D4, - .affineAnims = gUnknown_847A850, + .oam = &sOamData_Numbers, + .anims = sAnimTable_Numbers, + .affineAnims = sAffineAnimTable_Numbers, .callback = SpriteCallbackDummy }; spriteTemplate.tileTag = tilesTag; @@ -304,11 +315,11 @@ u8 sub_815F5BC(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority) return CreateSprite(&spriteTemplate, x, y, subpriority); } -void sub_815F610(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p) +static void CreateStartSprite(u16 tilesTag, u16 palTag, s16 x, s16 y, u8 subpriority, s16 * spriteId2_p, s16 * spriteId3_p) { struct SpriteTemplate spriteTemplate = { - .oam = &gOamData_847A7B4, - .anims = gUnknown_847A7F0, + .oam = &sOamData_Start, + .anims = sAnimTable_Start, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c index 8384d211d..cdfd62624 100644 --- a/src/mystery_gift_menu.c +++ b/src/mystery_gift_menu.c @@ -25,6 +25,7 @@ #include "help_system.h" #include "strings.h" #include "constants/songs.h" +#include "constants/union_room.h" EWRAM_DATA u8 sDownArrowCounterAndYCoordIdx[8] = {}; EWRAM_DATA bool8 gGiftIsFromEReader = FALSE; @@ -1237,21 +1238,21 @@ void task00_mystery_gift(u8 taskId) case 0: if (data->source == 1) { - MEvent_CreateTask_CardOrNewsWithFriend(0x15); + MEvent_CreateTask_CardOrNewsWithFriend(ACTIVITY_WCARD2); } else if (data->source == 0) { - MEvent_CreateTask_CardOrNewsOverWireless(0x15); + MEvent_CreateTask_CardOrNewsOverWireless(ACTIVITY_WCARD2); } break; case 1: if (data->source == 1) { - MEvent_CreateTask_CardOrNewsWithFriend(0x16); + MEvent_CreateTask_CardOrNewsWithFriend(ACTIVITY_WNEWS2); } else if (data->source == 0) { - MEvent_CreateTask_CardOrNewsOverWireless(0x16); + MEvent_CreateTask_CardOrNewsOverWireless(ACTIVITY_WNEWS2); } break; } @@ -1278,7 +1279,7 @@ void task00_mystery_gift(u8 taskId) switch (mevent_client_do_exec(&data->curPromptWindowId)) { case 6: // done - task_add_05_task_del_08FA224_when_no_RfuFunc(); + Rfu_BeginBuildAndSendCommand5F(); data->prevPromptWindowId = data->curPromptWindowId; data->state = 13; break; @@ -1595,10 +1596,10 @@ void task00_mystery_gift(u8 taskId) switch (data->IsCardOrNews) { case 0: - MEvent_CreateTask_Leader(21); + MEvent_CreateTask_Leader(ACTIVITY_WCARD2); break; case 1: - MEvent_CreateTask_Leader(22); + MEvent_CreateTask_Leader(ACTIVITY_WNEWS2); break; } data->source = 1; @@ -1644,7 +1645,7 @@ void task00_mystery_gift(u8 taskId) } break; case 33: - task_add_05_task_del_08FA224_when_no_RfuFunc(); + Rfu_BeginBuildAndSendCommand5F(); StringCopy(gStringVar1, gLinkPlayers[1].name); data->state = 34; break; diff --git a/src/new_game.c b/src/new_game.c index 05fb9c83e..9aea0b3aa 100644 --- a/src/new_game.c +++ b/src/new_game.c @@ -145,7 +145,7 @@ void NewGameInitData(void) ResetTrainerFanClub(); UnionRoomChat_InitializeRegisteredTexts(); ResetMiniGamesResults(); - sub_8143D24(); + InitMEventData(); SetAllRenewableItemFlags(); WarpToPlayersRoom(); ScriptContext2_RunNewScript(EventScript_ResetAllMapFlags); diff --git a/src/party_menu.c b/src/party_menu.c index df0e70b37..600350ca9 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -3881,7 +3881,7 @@ static void CursorCB_Register(u8 taskId) u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE); - switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)sub_80F9800(), species2, species, obedience)) + switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)GetHostRFUtgtGname(), species2, species, obedience)) { case CANT_REGISTER_MON: StringExpandPlaceholders(gStringVar4, gText_PkmnCantBeTradedNow); @@ -3907,7 +3907,7 @@ static void CursorCB_Trade1(u8 taskId) u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE); - u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)sub_80F9800(), gUnknown_203B064, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience); + u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)GetHostRFUtgtGname(), gPartnerTgtGnameSub, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience); if (stringId != UR_TRADE_MSG_NONE) { diff --git a/src/pokedex_screen.c b/src/pokedex_screen.c index 2ccec7a3f..cd201a884 100644 --- a/src/pokedex_screen.c +++ b/src/pokedex_screen.c @@ -562,8 +562,8 @@ void sub_8102F80(u8 taskId) switch (gUnknown_203ACF0->field_01) { case 0: - sub_8107D38(0x10, 0); - sub_8107D38(0x20, 1); + ListMenuLoadStdPalAt(0x10, 0); + ListMenuLoadStdPalAt(0x20, 1); gUnknown_203ACF0->field_48 = sub_8103518(gUnknown_203ACF0->field_42); gUnknown_203ACF0->field_01 = 2; break; @@ -648,8 +648,8 @@ void sub_8103238(u8 taskId) switch (gUnknown_203ACF0->field_01) { case 0: - sub_8107D38(0x10, 0); - sub_8107D38(0x20, 1); + ListMenuLoadStdPalAt(0x10, 0); + ListMenuLoadStdPalAt(0x20, 1); gUnknown_203ACF0->field_48 = sub_8103518(gUnknown_203ACF0->field_42); gUnknown_203ACF0->field_01 = 2; break; diff --git a/src/rfu_union_tool.c b/src/rfu_union_tool.c index 3811aa3e7..1d33fb7d1 100644 --- a/src/rfu_union_tool.c +++ b/src/rfu_union_tool.c @@ -10,14 +10,15 @@ #include "task.h" #include "constants/flags.h" #include "constants/event_object_movement.h" +#include "constants/union_room.h" #include "constants/object_events.h" static EWRAM_DATA struct UnionObj * UnionObjWork = NULL; static EWRAM_DATA u32 sUnionObjRefreshTimer = 0; static u8 StartUnionObjAnimTask(void); -static u32 sub_811BBC8(u32 playerIdx, u32 arg1); -static void sub_811C008(s32 arg0, s32 arg1, u8 arg2); +static u32 RfuUnionGroupMemberIsInvisible(u32 group, u32 member); +static void UnionPartnerObjectSetFacing(s32 member, s32 group, u8 direction); static const u8 sUnionObjectEventGfxIds[][10] = { [MALE] = { @@ -69,12 +70,12 @@ static const u8 sOppositeFacingDirection[] = { [DIR_EAST] = DIR_WEST }; -static const u8 gUnknown_845711B[] = { - 1, - 3, - 1, - 4, - 2 +static const u8 sUnionGroupMemberFacings[] = { + DIR_SOUTH, + DIR_WEST, + DIR_SOUTH, + DIR_EAST, + DIR_NORTH }; static const u8 sUnionRoomLocalIds[] = { @@ -116,19 +117,19 @@ static u8 GetUnionRoomPlayerGraphicsId(u32 gender, u32 id) return sUnionObjectEventGfxIds[gender][id % 8]; } -static void GetUnionRoomPlayerFacingCoords(u32 id, u32 dirn, s32 * xp, s32 * yp) +static void GetUnionRoomPlayerFacingCoords(u32 group, u32 member, s32 * xp, s32 * yp) { - *xp = sUnionPartnerCoords[id][0] + sFacingDirectionOffsets[dirn][0] + 7; - *yp = sUnionPartnerCoords[id][1] + sFacingDirectionOffsets[dirn][1] + 7; + *xp = sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[member][0] + 7; + *yp = sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[member][1] + 7; } -static bool32 sub_811B58C(u32 id, u32 dirn, s32 x, s32 y) +static bool32 IsUnionRoomPlayerFacingTileAt(u32 group, u32 member, s32 x, s32 y) { - if (sUnionPartnerCoords[id][0] + sFacingDirectionOffsets[dirn][0] + 7 != x) + if (sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[member][0] + 7 != x) { return FALSE; } - else if (sUnionPartnerCoords[id][1] + sFacingDirectionOffsets[dirn][1] + 7 != y) + else if (sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[member][1] + 7 != y) { return FALSE; } @@ -188,6 +189,7 @@ static bool32 SetUnionRoomPlayerEnterExitMovement(u32 playerIdx, const u8 * move } return TRUE; } + static bool32 TryReleaseUnionRoomPlayerObjectEvent(u32 playerIdx) { u8 objectId; @@ -263,11 +265,11 @@ static const u8 sMovement_UnionPlayerEnter[2] = { MOVEMENT_ACTION_STEP_END }; -static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionObj * ptr) +static bool32 AnimateUnionRoomPlayerSpawn(s8 * state_p, u32 playerIdx, struct UnionObj * ptr) { s16 x, y; - switch (*a0) + switch (*state_p) { case 0: if (!is_walking_or_running()) @@ -275,30 +277,30 @@ static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionOb break; } PlayerGetDestCoords(&x, &y); - if (sub_811B58C(playerIdx, 0, x, y) == TRUE) + if (IsUnionRoomPlayerFacingTileAt(playerIdx, 0, x, y) == TRUE) { break; } player_get_pos_including_state_based_drift(&x, &y); - if (sub_811B58C(playerIdx, 0, x, y) == TRUE) + if (IsUnionRoomPlayerFacingTileAt(playerIdx, 0, x, y) == TRUE) { break; } SetUnionRoomPlayerGfx(playerIdx, ptr->gfxId); CreateUnionRoomPlayerObjectEvent(playerIdx); ShowUnionRoomPlayer(playerIdx); - (*a0)++; + (*state_p)++; // fallthrough case 3: // incorrect? if (SetUnionRoomPlayerEnterExitMovement(playerIdx, sMovement_UnionPlayerEnter) == 1) { - (*a0)++; + (*state_p)++; } break; case 2: if (TryReleaseUnionRoomPlayerObjectEvent(playerIdx)) { - *a0 = 0; + *state_p = 0; return TRUE; } break; @@ -306,12 +308,12 @@ static bool32 AnimateUnionRoomPlayerSpawn(s8 * a0, u32 playerIdx, struct UnionOb return FALSE; } -static bool32 sub_811B8BC(u32 playerIdx, u32 a1, u32 a2) +static bool32 SpawnGroupLeader(u32 playerIdx, u32 gender, u32 idMod256) { struct UnionObj * ptr = &UnionObjWork[playerIdx]; AGB_ASSERT_EX(UnionObjWork != NULL, ABSPATH("rfu_union_tool.c"), 561) - ptr->schedAnim = 1; - ptr->gfxId = GetUnionRoomPlayerGraphicsId(a1, a2); + ptr->schedAnim = UNION_ROOM_SPAWN_IN; + ptr->gfxId = GetUnionRoomPlayerGraphicsId(gender, idMod256); if (ptr->state == 0) { return TRUE; @@ -322,11 +324,11 @@ static bool32 sub_811B8BC(u32 playerIdx, u32 a1, u32 a2) } } -static bool32 sub_811B90C(u32 playerIdx) +static bool32 DespawnGroupLeader(u32 playerIdx) { struct UnionObj * ptr = &UnionObjWork[playerIdx]; AGB_ASSERT_EX(UnionObjWork != NULL, ABSPATH("rfu_union_tool.c"), 577) - ptr->schedAnim = 2; + ptr->schedAnim = UNION_ROOM_SPAWN_OUT; if (ptr->state == 1) { return TRUE; @@ -342,7 +344,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr) switch (ptr->state) { case 0: - if (ptr->schedAnim == 1) + if (ptr->schedAnim == UNION_ROOM_SPAWN_IN) { ptr->state = 2; ptr->animState = 0; @@ -353,7 +355,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr) } // fallthrough case 2: - if (!sub_811BBC8(playerIdx, 0) && ptr->schedAnim == 2) + if (!RfuUnionGroupMemberIsInvisible(playerIdx, 0) && ptr->schedAnim == 2) { ptr->state = 0; ptr->animState = 0; @@ -366,7 +368,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr) } break; case 1: - if (ptr->schedAnim == 2) + if (ptr->schedAnim == UNION_ROOM_SPAWN_OUT) { ptr->state = 3; ptr->animState = 0; @@ -383,7 +385,7 @@ static void AnimateUnionObj(u32 playerIdx, struct UnionObj * ptr) } break; } - ptr->schedAnim = 0; + ptr->schedAnim = UNION_ROOM_SPAWN_NONE; } static void Task_AnimateUnionObjs(u8 taskId) @@ -409,7 +411,7 @@ static u8 StartUnionObjAnimTask(void) } } -static void sub_811BA5C(void) +static void DestroyAnimateUnionObjsTask(void) { u8 taskId = FindTaskIdByFunc(Task_AnimateUnionObjs); if (taskId < NUM_TASKS) @@ -418,7 +420,7 @@ static void sub_811BA5C(void) } } -void sub_811BA78(void) +void DeleteUnionObjWorkAndStopTask(void) { s32 i; for (i = 0; i < 8; i++) @@ -430,31 +432,31 @@ void sub_811BA78(void) } } UnionObjWork = NULL; - sub_811BA5C(); + DestroyAnimateUnionObjsTask(); } -void sub_811BAAC(u8 * sp8, s32 r9) +void CreateGroupMemberObjectsInvisible(u8 * sprite_ids, s32 group) { - s32 r7; + s32 i; - for (r7 = 0; r7 < 5; r7++) + for (i = 0; i < 5; i++) { - s32 r5 = 5 * r9 + r7; - sp8[r5] = sprite_new(OBJECT_EVENT_GFX_MAN, r5 - 0x38, sUnionPartnerCoords[r9][0] + sFacingDirectionOffsets[r7][0], sUnionPartnerCoords[r9][1] + sFacingDirectionOffsets[r7][1], 3, 1); - RfuUnionObjectToggleInvisibility(r5 - 0x38, TRUE); + s32 obj_id = 5 * group + i; + sprite_ids[obj_id] = sprite_new(OBJECT_EVENT_GFX_MAN, obj_id - 0x38, sUnionPartnerCoords[group][0] + sFacingDirectionOffsets[i][0], sUnionPartnerCoords[group][1] + sFacingDirectionOffsets[i][1], 3, 1); + RfuUnionObjectToggleInvisibility(obj_id - 0x38, TRUE); } } -void sub_811BB40(u8 * r5) +void DestroyGroupMemberObjects(u8 *spriteIds) { s32 i; for (i = 0; i < 40; i++) { - DestroySprite(&gSprites[r5[i]]); + DestroySprite(&gSprites[spriteIds[i]]); } } -void sub_811BB68(void) +void MakeGroupAssemblyAreasPassable(void) { s32 i, j, x, y; for (i = 0; i < 8; i++) @@ -462,94 +464,94 @@ void sub_811BB68(void) for (j = 0; j < 5; j++) { GetUnionRoomPlayerFacingCoords(i, j, &x, &y); - sub_8059024(x, y, 0); + MapGridSetMetatileImpassabilityAt(x, y, FALSE); } } } -static u8 sub_811BBA0(u32 r1, u32 unused, struct GFtgtGname * r2) +static u8 UnionPartnerObjectGetFacing(u32 member, u32 group, struct GFtgtGname * gname) { - if (r1 != 0) + if (member != 0) { - return gUnknown_845711B[r1]; + return sUnionGroupMemberFacings[member]; } - else if (r2->unk_0a_0 == 0x45) + else if (gname->activity == 0x45) { - return 1; + return DIR_SOUTH; } else { - return 4; + return DIR_EAST; } } -static u32 sub_811BBC8(u32 a0, u32 a1) +static u32 RfuUnionGroupMemberIsInvisible(u32 group, u32 member) { - return RfuUnionObjectIsInvisible(5 * a0 + a1 - 0x38); + return RfuUnionObjectIsInvisible(5 * group + member - 0x38); } -static void sub_811BBE0(u32 r5, u32 r6, u8 r8, struct GFtgtGname * r9) +static void SpawnGroupMember(u32 groupNo, u32 memberNo, u8 direction, struct GFtgtGname * gname) { s32 x, y; - s32 r7 = 5 * r5 + r6; - if (sub_811BBC8(r5, r6) == 1) + s32 objId = 5 * groupNo + memberNo; + if (RfuUnionGroupMemberIsInvisible(groupNo, memberNo) == TRUE) { - RfuUnionObjectToggleInvisibility(r7 - 0x38, FALSE); - RfuUnionObjectStartWarp(r7 - 0x38, 1); + RfuUnionObjectToggleInvisibility(objId - 0x38, FALSE); + RfuUnionObjectStartWarp(objId - 0x38, UNION_ROOM_SPAWN_IN); } - RfuUnionObjectSetFacingDirection(r7 - 0x38, r8); - sub_811C008(r6, r5, sub_811BBA0(r6, r5, r9)); - GetUnionRoomPlayerFacingCoords(r5, r6, &x, &y); - sub_8059024(x, y, 1); + RfuUnionObjectSetFacingDirection(objId - 0x38, direction); + UnionPartnerObjectSetFacing(memberNo, groupNo, UnionPartnerObjectGetFacing(memberNo, groupNo, gname)); + GetUnionRoomPlayerFacingCoords(groupNo, memberNo, &x, &y); + MapGridSetMetatileImpassabilityAt(x, y, TRUE); } -static void sub_811BC68(u32 a0, u32 a1) +static void DespawnGroupMember(u32 group, u32 member) { s32 x, y; - RfuUnionObjectStartWarp(5 * a0 + a1 - 0x38, 2); - GetUnionRoomPlayerFacingCoords(a0, a1, &x, &y); - sub_8059024(x, y, 0); + RfuUnionObjectStartWarp(5 * group + member - 0x38, UNION_ROOM_SPAWN_OUT); + GetUnionRoomPlayerFacingCoords(group, member, &x, &y); + MapGridSetMetatileImpassabilityAt(x, y, FALSE); } -static void sub_811BCA0(u32 r7, struct GFtgtGname * r8) +static void AssembleGroup(u32 group, struct GFtgtGname * gname) { s16 x, y, x2, y2; s32 i; PlayerGetDestCoords(&x, &y); player_get_pos_including_state_based_drift(&x2, &y2); - if (RfuUnionObjectIsInvisible(5 * r7 - 0x38) == 1) + if (RfuUnionObjectIsInvisible(5 * group - 0x38) == TRUE) { - if (sub_811B58C(r7, 0, x, y) == TRUE || sub_811B58C(r7, 0, x2, y2) == TRUE) + if (IsUnionRoomPlayerFacingTileAt(group, 0, x, y) == TRUE || IsUnionRoomPlayerFacingTileAt(group, 0, x2, y2) == TRUE) { return; } - sub_811BBE0(r7, 0, GetUnionRoomPlayerGraphicsId(r8->playerGender, r8->unk_00.playerTrainerId[0]), r8); + SpawnGroupMember(group, 0, GetUnionRoomPlayerGraphicsId(gname->playerGender, gname->unk_00.playerTrainerId[0]), gname); } for (i = 1; i < 5; i++) { - if (r8->unk_04[i - 1] == 0) + if (gname->child_sprite_gender[i - 1] == 0) { - sub_811BC68(r7, i); + DespawnGroupMember(group, i); } - else if (sub_811B58C(r7, i, x, y) == FALSE && sub_811B58C(r7, i, x2, y2) == FALSE) + else if (IsUnionRoomPlayerFacingTileAt(group, i, x, y) == FALSE && IsUnionRoomPlayerFacingTileAt(group, i, x2, y2) == FALSE) { - sub_811BBE0(r7, i, GetUnionRoomPlayerGraphicsId((r8->unk_04[i - 1] >> 3) & 1, r8->unk_04[i - 1] & 7), r8); + SpawnGroupMember(group, i, GetUnionRoomPlayerGraphicsId((gname->child_sprite_gender[i - 1] >> 3) & 1, gname->child_sprite_gender[i - 1] & 7), gname); } } } -static void sub_811BDA8(u32 r5, struct GFtgtGname * r4) +static void SpawnGroupLeaderAndMembers(u32 group, struct GFtgtGname * gname) { u32 i; - switch (r4->unk_0a_0) + switch (gname->activity) { case 0x40: case 0x54: - sub_811B8BC(r5, r4->playerGender, r4->unk_00.playerTrainerId[0]); + SpawnGroupLeader(group, gname->playerGender, gname->unk_00.playerTrainerId[0]); for (i = 0; i < 5; i++) { - sub_811BC68(r5, i); + DespawnGroupMember(group, i); } break; case 0x41: @@ -559,70 +561,70 @@ static void sub_811BDA8(u32 r5, struct GFtgtGname * r4) case 0x51: case 0x52: case 0x53: - sub_811B90C(r5); - sub_811BCA0(r5, r4); + DespawnGroupLeader(group); + AssembleGroup(group, gname); break; default: AGB_ASSERT_EX(0, ABSPATH("rfu_union_tool.c"), 979) } } -static void sub_811BE6C(u32 r5, struct GFtgtGname * unused) +static void DespawnGroupLeaderAndMembers(u32 group, struct GFtgtGname * gname) { s32 i; - sub_811B90C(r5); + DespawnGroupLeader(group); for (i = 0; i < 5; i++) { - sub_811BC68(r5, i); + DespawnGroupMember(group, i); } } -static void UpdateUnionRoomPlayerSprites(struct UnkStruct_URoom *r0) +static void UpdateUnionRoomPlayerSprites(struct UnkStruct_URoom * groups) { s32 i; - struct UnkStruct_x20 * r4; + struct UnkStruct_x20 * x20_p; sUnionObjRefreshTimer = 0; - for (i = 0, r4 = r0->field_0->arr; i < 8; i++) + for (i = 0, x20_p = groups->field_0->arr; i < 8; i++) { - if (r4[i].field_1A_0 == 1) + if (x20_p[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - sub_811BDA8(i, &r4[i].unk.gname); + SpawnGroupLeaderAndMembers(i, &x20_p[i].gname_uname.gname); } - else if (r4[i].field_1A_0 == 2) + else if (x20_p[i].groupScheduledAnim == UNION_ROOM_SPAWN_OUT) { - sub_811BE6C(i, &r4[i].unk.gname); + DespawnGroupLeaderAndMembers(i, &x20_p[i].gname_uname.gname); } } } -void sub_811BECC(struct UnkStruct_URoom *unused) +void ScheduleUnionRoomPlayerRefresh(struct UnkStruct_URoom *uroom_p) { sUnionObjRefreshTimer = 300; } -void sub_811BEDC(struct UnkStruct_URoom *r2) +void HandleUnionRoomPlayerRefresh(struct UnkStruct_URoom *uroom_p) { if (++sUnionObjRefreshTimer > 300) { - UpdateUnionRoomPlayerSprites(r2); + UpdateUnionRoomPlayerSprites(uroom_p); } } -bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3) +bool32 RfuUnionTool_GetGroupAndMemberInFrontOfPlayer(struct UnkStruct_Main0 *main0_p, s16 *member_p, s16 *group_p, u8 *spriteIds) { s16 x, y; s32 i, j; - struct UnkStruct_x20 * r4; + struct UnkStruct_x20 * x20_p; if (!is_walking_or_running()) { return FALSE; } GetXYCoordsOneStepInFrontOfPlayer(&x, &y); - for (i = 0, r4 = arg0->arr; i < 8; i++) + for (i = 0, x20_p = main0_p->arr; i < 8; i++) { for (j = 0; j < 5; j++) { - s32 r3 = 5 * i + j; + s32 objId = 5 * i + j; if (x != sUnionPartnerCoords[i][0] + sFacingDirectionOffsets[j][0] + 7) { continue; @@ -631,33 +633,33 @@ bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3) { continue; } - if (RfuUnionObjectIsInvisible(r3 - 0x38) != 0) + if (RfuUnionObjectIsInvisible(objId - 0x38) != 0) { continue; } - if (RfuUnionObjectIsWarping(r3 - 0x38) != 0) + if (RfuUnionObjectIsWarping(objId - 0x38) != 0) { continue; } - if (r4[i].field_1A_0 != 1) + if (x20_p[i].groupScheduledAnim != UNION_ROOM_SPAWN_IN) { continue; } - sub_811C008(j, i, sOppositeFacingDirection[GetPlayerFacingDirection()]); - *arg1 = j; - *arg2 = i; + UnionPartnerObjectSetFacing(j, i, sOppositeFacingDirection[GetPlayerFacingDirection()]); + *member_p = j; + *group_p = i; return TRUE; } } return FALSE; } -static void sub_811C008(s32 arg0, s32 arg1, u8 arg2) +static void UnionPartnerObjectSetFacing(s32 member, s32 group, u8 direction) { - TurnObjectEvent(5 * arg1 - 0x38 + arg0, arg2); + TurnObjectEvent(5 * group - 0x38 + member, direction); } -void sub_811C028(u32 arg0, u32 arg1, struct UnkStruct_Main0 *arg2) +void UpdateUnionGroupMemberFacing(u32 member, u32 group, struct UnkStruct_Main0 *main0_p) { - return sub_811C008(arg0, arg1, sub_811BBA0(arg0, arg1, &arg2->arr[arg1].unk.gname)); + return UnionPartnerObjectSetFacing(member, group, UnionPartnerObjectGetFacing(member, group, &main0_p->arr[group].gname_uname.gname)); } diff --git a/src/save.c b/src/save.c index a2d365886..3db8dcdbf 100644 --- a/src/save.c +++ b/src/save.c @@ -856,7 +856,7 @@ void sub_80DA634(u8 taskId) gTasks[taskId].data[0] = 1; break; case 1: - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gTasks[taskId].data[0] = 2; break; case 2: @@ -890,7 +890,7 @@ void sub_80DA634(u8 taskId) break; case 7: ClearContinueGameWarpStatus2(); - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gTasks[taskId].data[0] = 8; break; case 8: @@ -901,7 +901,7 @@ void sub_80DA634(u8 taskId) } break; case 9: - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gTasks[taskId].data[0] = 10; break; case 10: diff --git a/src/script.c b/src/script.c index 0a4b69bac..ee4ffb7cf 100644 --- a/src/script.c +++ b/src/script.c @@ -506,7 +506,7 @@ u8 *GetRamScript(u8 objectId, u8 *script) } } -bool32 sub_8069DFC(void) +bool32 ValidateRamScript(void) { struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data; if (scriptData->magic != RAM_SCRIPT_MAGIC) diff --git a/src/sprite.c b/src/sprite.c index c1fc89777..fd824494b 100644 --- a/src/sprite.c +++ b/src/sprite.c @@ -94,17 +94,17 @@ typedef void (*AffineAnimCmdFunc)(u8 matrixNum, struct Sprite *); #define DUMMY_OAM_DATA \ { \ 160, /* Y (off-screen) */ \ - 0, \ - 0, \ - 0, \ - 0, \ - 0, \ + ST_OAM_AFFINE_OFF, \ + ST_OAM_OBJ_NORMAL, \ + FALSE, \ + ST_OAM_4BPP, \ + ST_OAM_SQUARE, \ 304, /* X */ \ 0, \ - 0, \ - 0, \ + ST_OAM_SIZE_0, \ + 0x000, \ 3, /* lowest priority */ \ - 0, \ + 0x0, \ 0 \ } @@ -250,47 +250,47 @@ static const AffineAnimCmdFunc sAffineAnimCmdFuncs[] = AffineAnimCmd_frame, }; -static const s32 sUnknown_082EC6F4[3][4][2] = +static const s32 sOamDimensionsCopy[3][4][2] = { - { - {8, 8}, - {0x10, 0x10}, - {0x20, 0x20}, - {0x40, 0x40}, + [ST_OAM_SQUARE] = { + [ST_OAM_SIZE_0] = { 8, 8}, // SPRITE_SIZE_8x8 + [ST_OAM_SIZE_1] = {16, 16}, // SPRITE_SIZE_16x16 + [ST_OAM_SIZE_2] = {32, 32}, // SPRITE_SIZE_32x32 + [ST_OAM_SIZE_3] = {64, 64}, // SPRITE_SIZE_64x64 }, - { - {0x10, 8}, - {0x20, 8}, - {0x20, 0x10}, - {0x40, 0x20}, + [ST_OAM_H_RECTANGLE] = { + [ST_OAM_SIZE_0] = {16, 8}, // SPRITE_SIZE_16x8 + [ST_OAM_SIZE_1] = {32, 8}, // SPRITE_SIZE_32x8 + [ST_OAM_SIZE_2] = {32, 16}, // SPRITE_SIZE_32x16 + [ST_OAM_SIZE_3] = {64, 32}, // SPRITE_SIZE_64x32 }, - { - {8, 0x10}, - {8, 0x20}, - {0x10, 0x20}, - {0x20, 0x40}, + [ST_OAM_V_RECTANGLE] = { + [ST_OAM_SIZE_0] = { 8, 16}, // SPRITE_SIZE_8x16 + [ST_OAM_SIZE_1] = { 8, 32}, // SPRITE_SIZE_8x32 + [ST_OAM_SIZE_2] = {16, 32}, // SPRITE_SIZE_16x32 + [ST_OAM_SIZE_3] = {32, 64}, // SPRITE_SIZE_32x64 }, }; static const struct OamDimensions sOamDimensions[3][4] = { - { // square - { 8, 8 }, - { 16, 16 }, - { 32, 32 }, - { 64, 64 }, + [ST_OAM_SQUARE] = { + [ST_OAM_SIZE_0] = { 8, 8}, // SPRITE_SIZE_8x8 + [ST_OAM_SIZE_1] = {16, 16}, // SPRITE_SIZE_16x16 + [ST_OAM_SIZE_2] = {32, 32}, // SPRITE_SIZE_32x32 + [ST_OAM_SIZE_3] = {64, 64}, // SPRITE_SIZE_64x64 }, - { // horizontal rectangle - { 16, 8 }, - { 32, 8 }, - { 32, 16 }, - { 64, 32 }, + [ST_OAM_H_RECTANGLE] = { + [ST_OAM_SIZE_0] = {16, 8}, // SPRITE_SIZE_16x8 + [ST_OAM_SIZE_1] = {32, 8}, // SPRITE_SIZE_32x8 + [ST_OAM_SIZE_2] = {32, 16}, // SPRITE_SIZE_32x16 + [ST_OAM_SIZE_3] = {64, 32}, // SPRITE_SIZE_64x32 }, - { // vertical rectangle - { 8, 16 }, - { 8, 32 }, - { 16, 32 }, - { 32, 64 }, + [ST_OAM_V_RECTANGLE] = { + [ST_OAM_SIZE_0] = { 8, 16}, // SPRITE_SIZE_8x16 + [ST_OAM_SIZE_1] = { 8, 32}, // SPRITE_SIZE_8x32 + [ST_OAM_SIZE_2] = {16, 32}, // SPRITE_SIZE_16x32 + [ST_OAM_SIZE_3] = {32, 64}, // SPRITE_SIZE_32x64 }, }; @@ -1222,43 +1222,43 @@ u8 GetSpriteMatrixNum(struct Sprite *sprite) return matrixNum; } -void sub_8007FFC(struct Sprite* sprite, s16 a2, s16 a3) +void obj_pos2_update_enable(struct Sprite* sprite, s16 xmod, s16 ymod) { - sprite->data[6] = a2; - sprite->data[7] = a3; + sprite->data[6] = xmod; + sprite->data[7] = ymod; sprite->flags_f = 1; } -s32 sub_800800C(s32 a0, s32 a1, s32 a2) +static s32 affine_get_new_pos2(s32 baseDim, s32 xformed, s32 modifier) { - s32 subResult, var1; + s32 subResult, shiftResult; - subResult = a1 - a0; + subResult = xformed - baseDim; if (subResult < 0) - var1 = -(subResult) >> 9; + shiftResult = -(subResult) >> 9; else - var1 = -(subResult >> 9); - return a2 - ((u32)(a2 * a1) / (u32)(a0) + var1); + shiftResult = -(subResult >> 9); + return modifier - ((u32)(modifier * xformed) / (u32)(baseDim) + shiftResult); } -void obj_update_pos2(struct Sprite *sprite, s32 a1, s32 a2) +static void obj_update_pos2(struct Sprite *sprite, s32 xmod, s32 ymod) { - s32 var0, var1, var2; + s32 dim, baseDim, xFormed; u32 matrixNum = sprite->oam.matrixNum; - if (a1 != 0x800) + if (xmod != 0x800) { - var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][0]; - var1 = var0 << 8; - var2 = (var0 << 16) / gOamMatrices[matrixNum].a; - sprite->pos2.x = sub_800800C(var1, var2, a1); + dim = sOamDimensionsCopy[sprite->oam.shape][sprite->oam.size][0]; + baseDim = dim << 8; + xFormed = (dim << 16) / gOamMatrices[matrixNum].a; + sprite->pos2.x = affine_get_new_pos2(baseDim, xFormed, xmod); } - if (a2 != 0x800) + if (ymod != 0x800) { - var0 = sUnknown_082EC6F4[sprite->oam.shape][sprite->oam.size][1]; - var1 = var0 << 8; - var2 = (var0 << 16) / gOamMatrices[matrixNum].d; - sprite->pos2.y = sub_800800C(var1, var2, a2); + dim = sOamDimensionsCopy[sprite->oam.shape][sprite->oam.size][1]; + baseDim = dim << 8; + xFormed = (dim << 16) / gOamMatrices[matrixNum].d; + sprite->pos2.y = affine_get_new_pos2(baseDim, xFormed, ymod); } } diff --git a/src/tm_case.c b/src/tm_case.c index d45061bde..ac4134029 100644 --- a/src/tm_case.c +++ b/src/tm_case.c @@ -1304,7 +1304,7 @@ static void InitWindowTemplatesAndPals(void) LoadPalette(gTMCaseMainWindowPalette, 0xA0, 0x20); LoadPalette(sPal3Override, 0xF6, 0x04); LoadPalette(sPal3Override, 0xD6, 0x04); - sub_8107D38(0xc0, 0x01); + ListMenuLoadStdPalAt(0xc0, 0x01); for (i = 0; i < 9; i++) FillWindowPixelBuffer(i, 0x00); PutWindowTilemap(0); diff --git a/src/trade.c b/src/trade.c index fe5f53be9..1872e98ee 100644 --- a/src/trade.c +++ b/src/trade.c @@ -765,9 +765,9 @@ static void sub_804C728(void) if (gWirelessCommType) { - sub_800B1F4(); + SetWirelessCommType1(); OpenLink(); - sub_80FBB20(); + LinkRfu_CreateIdleTask(); } else { @@ -810,14 +810,14 @@ static void sub_804C728(void) case 4: if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE) { - sub_80FBB4C(); + LinkRfu_DestroyIdleTask(); CalculatePlayerPartyCount(); gMain.state++; sTradeMenuResourcesPtr->unk_A8 = 0; if (gWirelessCommType) { sub_80FA484(TRUE); - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); } } break; @@ -1213,7 +1213,7 @@ static void sub_804D548(void) } else { - sub_800AA80(32); + Link_StartSend5FFFwithParam(32); sTradeMenuResourcesPtr->unk_6F = 13; } } @@ -2004,11 +2004,11 @@ static void sub_804E908(void) { if (gWirelessCommType) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); } else { - sub_800AA80(12); + Link_StartSend5FFFwithParam(12); } sTradeMenuResourcesPtr->unk_6F = 12; @@ -2044,7 +2044,7 @@ static void sub_804E9C0(void) { if (!sub_80FA484(FALSE)) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); sTradeMenuResourcesPtr->unk_6F = 13; } } @@ -2740,30 +2740,30 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet) return FALSE; } -int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) +int GetUnionRoomTradeMessageId(struct GFtgtGnameSub playerSub, struct GFtgtGnameSub partnerSub, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) { - u8 r9 = a0.hasNationalDex; - u8 r4 = a0.isChampion; - u8 r10 = a1.hasNationalDex; - u8 r0 = a1.isChampion; - u8 r1 = a1.unk_01_2; - u8 r2; + u8 playerHasNationalDex = playerSub.hasNationalDex; + u8 playerIsChampion = playerSub.isChampion; + u8 partnerHasNationalDex = partnerSub.hasNationalDex; + u8 partnerIsChampion = partnerSub.isChampion; + u8 partnerVersion = partnerSub.version; + bool8 isNotFRLG; - if (r1 == VERSION_FIRE_RED || r1 == VERSION_LEAF_GREEN) + if (partnerVersion == VERSION_FIRE_RED || partnerVersion == VERSION_LEAF_GREEN) { - r2 = 0; + isNotFRLG = FALSE; } else { - r2 = 1; + isNotFRLG = TRUE; } - if (r2) + if (isNotFRLG) { - if (!r4) + if (!playerIsChampion) { return 8; } - else if (!r0) + else if (!partnerIsChampion) { return 9; } @@ -2794,7 +2794,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, return 3; } - if (!r9) + if (!playerHasNationalDex) { if (species1 == SPECIES_EGG) { @@ -2812,7 +2812,7 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, } } - if (!r10 && species1 > SPECIES_MEW) + if (!partnerHasNationalDex && species1 > SPECIES_MEW) { return 7; } @@ -2820,11 +2820,11 @@ int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, return 0; } -int CanRegisterMonForTradingBoard(struct GFtgtGnameSub a0, u16 species, u16 a2, u8 a3) +int CanRegisterMonForTradingBoard(struct GFtgtGnameSub playerSub, u16 species2, u16 species, u8 obedience) { - u8 canTradeEggAndNational = a0.hasNationalDex; + u8 canTradeEggAndNational = playerSub.hasNationalDex; - if (IsDeoxysOrMewUntradable(a2, a3)) + if (IsDeoxysOrMewUntradable(species, obedience)) { return 1; } @@ -2834,12 +2834,12 @@ int CanRegisterMonForTradingBoard(struct GFtgtGnameSub a0, u16 species, u16 a2, return 0; } - if (species == SPECIES_EGG) + if (species2 == SPECIES_EGG) { return 2; } - if (species > SPECIES_MEW && species != SPECIES_EGG) + if (species2 > SPECIES_MEW && species2 != SPECIES_EGG) { return 1; } diff --git a/src/trade_scene.c b/src/trade_scene.c index b420cb196..601d7ae2b 100644 --- a/src/trade_scene.c +++ b/src/trade_scene.c @@ -2556,7 +2556,7 @@ static void sub_8053E8C(void) DrawTextOnTradeWindow(0, gStringVar4, 0); break; case 1: - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gMain.state = 100; sTradeData->timer = 0; break; @@ -2594,7 +2594,7 @@ static void sub_8053E8C(void) } if (gWirelessCommType) { - sub_8144714(2, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId); + MEvent_RecordIdOfWonderCardSenderByEventType(2, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId); } SetContinueGameWarpStatusToDynamicWarp(); sub_80DA3AC(); @@ -2641,7 +2641,7 @@ static void sub_8053E8C(void) case 41: if (sTradeData->timer == 0) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gMain.state = 42; } else @@ -2660,7 +2660,7 @@ static void sub_8053E8C(void) if (++sTradeData->timer > 60) { gMain.state++; - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); } break; case 6: @@ -2682,11 +2682,11 @@ static void sub_8053E8C(void) { if (gWirelessCommType && gMain.savedCallback == CB2_ReturnFromLinkTrade) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); } else { - sub_800AAC0(); + Link_TryStartSend5FFF(); } gMain.state++; } diff --git a/src/trainer_card.c b/src/trainer_card.c index e4778f5ed..f29c9c71c 100644 --- a/src/trainer_card.c +++ b/src/trainer_card.c @@ -590,7 +590,7 @@ static void Task_TrainerCard(u8 taskId) } break; case 15: - sub_800AAC0(); + Link_TryStartSend5FFF(); DrawDialogueFrame(0, 1); AddTextPrinterParameterized(0, 2, gText_WaitingTrainerFinishReading, 0, 1, TEXT_SPEED_FF, 0); CopyWindowToVram(0, 3); diff --git a/src/union_room.c b/src/union_room.c index f942fb7d3..f3aeeebc5 100644 --- a/src/union_room.c +++ b/src/union_room.c @@ -37,6 +37,7 @@ #include "trade_scene.h" #include "trainer_card.h" #include "union_room.h" +#include "union_room_battle.h" #include "union_room_chat.h" #include "rfu_union_tool.h" #include "union_room_message.h" @@ -45,13 +46,14 @@ #include "constants/cable_club.h" #include "constants/field_weather.h" #include "constants/species.h" +#include "constants/union_room.h" static EWRAM_DATA u8 sUnionRoomPlayerName[12] = {}; -static EWRAM_DATA u8 gUnknown_203B058 = 0; -static EWRAM_DATA u8 gUnknown_203B059 = 0; +static EWRAM_DATA u8 sPlayerCurrActivity = 0; +static EWRAM_DATA u8 sPlayerActivityGroupSize = 0; static EWRAM_DATA union UnkUnion_Main sUnionRoomMain = {}; static EWRAM_DATA u32 sUnref_203B060 = 0; -EWRAM_DATA struct GFtgtGnameSub gUnknown_203B064 = {}; +EWRAM_DATA struct GFtgtGnameSub gPartnerTgtGnameSub = {}; EWRAM_DATA u16 gUnionRoomOfferedSpecies = SPECIES_NONE; EWRAM_DATA u8 gUnionRoomRequestedMonType = TYPE_NORMAL; static EWRAM_DATA struct UnionRoomTrade sUnionRoomTrade = {}; @@ -60,103 +62,103 @@ static struct UnkStruct_Leader * sLeader; static struct UnkStruct_Group * sGroup; static struct UnkStruct_URoom * sURoom; -static void sub_8115A68(u8 taskId); -static void sub_81161E4(struct UnkStruct_Leader * leader); -static bool8 sub_8116444(struct UnkStruct_Leader * leader, u32 a1, u32 a2); -static void sub_81164C8(u8 windowId, s32 itemId, u8 y); -static u8 sub_8116524(struct UnkStruct_Main0 * a0); -static u8 sub_81165E8(struct UnkStruct_Main0 * a0); -static void sub_8116738(u8 taskId); -static u32 sub_8116D10(struct UnkStruct_Group * group, s32 id); -static void sub_8116D60(struct UnkStruct_Group * group, s32 id); -static void sub_8116E1C(u8 taskId); -static void sub_8116F94(u8 windowId, s32 itemId, u8 y); -static u8 sub_8116FE4(void); -static void sub_8117990(void); -static void sub_81179A4(void); -static void sub_8117A0C(u8 taskId); -static void sub_8117F20(u8 taskId); -static void sub_81182DC(u8 taskId); -static void sub_81186E0(u8 taskId); +static void Task_TryBecomeLinkLeader(u8 taskId); +static void Leader_DestroyResources(struct UnkStruct_Leader * leader); +static bool8 Leader_SetStateIfMemberListChanged(struct UnkStruct_Leader * leader, u32 state1, u32 state2); +static void ItemPrintFunc_PossibleGroupMembers(u8 windowId, s32 itemId, u8 y); +static u8 LeaderUpdateGroupMembership(struct UnkStruct_Main0 * main0); +static u8 UnionRoomLeaderField0CompactionAndCount(struct UnkStruct_Main0 * main0); +static void Task_TryJoinLinkGroup(u8 taskId); +static u32 IsTryingToTradeWithHoennTooSoon(struct UnkStruct_Group * group, s32 id); +static void AskToJoinRfuGroup(struct UnkStruct_Group * group, s32 id); +static void Task_ListenToWireless(u8 taskId); +static void ListMenuItemPrintFunc_UnionRoomGroups(u8 windowId, s32 itemId, u8 y); +static u8 GetNewLeaderCandidate(void); +static void CreateTask_RunScriptAndFadeToActivity(void); +static void CreateTask_StartActivity(void); +static void Task_MEvent_Leader(u8 taskId); +static void Task_CardOrNewsWithFriend(u8 taskId); +static void Task_CardOrNewsOverWireless(u8 taskId); +static void Task_RunUnionRoom(u8 taskId); static u16 ReadAsU16(const u8 *data); -static void sub_8119904(struct UnkStruct_URoom * uRoom); -static bool32 sub_8119944(struct UnkStruct_URoom * uRoom); -static void sub_81199FC(u8 taskId); -static u8 sub_8119B94(void); -static u8 sub_8119E84(struct UnkStruct_Main4 * arg0, struct UnkStruct_Main4 * arg1, u32 arg2); -static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1); -static u8 sub_811A054(struct UnkStruct_Main4 * arg0, u32 arg1); -static u8 sub_811A084(struct UnkStruct_Main4 * arg0, u32 arg1); -static bool32 sub_811A0B4(const u8 * str); -static bool32 sub_811A0E0(void); +static void ReceiveUnionRoomActivityPacket(struct UnkStruct_URoom * uRoom); +static bool32 UnionRoom_HandleContactFromOtherPlayer(struct UnkStruct_URoom * uRoom); +static void Task_InitUnionRoom(u8 taskId); +static u8 HandlePlayerListUpdate(void); +static u8 CreateTask_SearchForChildOrParent(struct UnkStruct_Main4 * main4, struct UnkStruct_Main4 * arg1, u32 arg2); +static bool32 GetGnameWonderFlagByLinkGroup(struct GFtgtGname * gname, s16 linkGroup); +static u8 CreateTask_ListenForPartnersWithCompatibleSerialNos(struct UnkStruct_Main4 * main4, u32 linkGroup); +static u8 CreateTask_ListenForPartnersWithSerial7F7D(struct UnkStruct_Main4 * main4, u32 linkGroup); +static bool32 UR_PrintFieldMessage(const u8 * str); +static bool32 UR_RunTextPrinters_CheckPrinter0Active(void); static bool8 PrintOnTextbox(u8 *textState, const u8 *str); -static s8 sub_811A14C(u8 *dest, bool32 arg1); -static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate); -static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * arg6); -static void sub_811A3F8(void); -static void sub_811A41C(void); -static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx); -static void sub_811A5E4(struct UnkStruct_x20 * arg0, u8 count); -static void sub_811A650(struct UnkStruct_x1C * arg0, u8 count); -static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_Shared * arg1); -static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Shared * arg1); -static u32 sub_811A748(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1); -static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1, u8 arg2); -static void sub_811A81C(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * arg3, u8 arg4, u8 id); -static void sub_811A910(u8 arg0, u8 arg1, u8 arg2, struct UnkStruct_x20 * arg3, u8 arg4, u8 id); -static bool32 sub_811A9B8(void); -static u32 sub_811A9FC(s32 a0); -static u32 sub_811AA24(struct UnkStruct_x20 * unkX20); -static s32 sub_811AA5C(struct UnkStruct_Main0 * arg0, u8 arg1, u8 arg2, u32 playerGender); +static s8 UnionRoomHandleYesNo(u8 *state_p, bool32 no_draw); +static s32 ListMenuHandler_AllItemsAvailable(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate); +static s32 TradeBoardMenuHandler(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, u8 *trade_board_win_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * traders); +static void UR_BlankBg0(void); +static void JoinGroup_BlankBg0AndEnableScriptContexts(void); +static void UR_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx); +static void BlankUnkStruct_x20Array(struct UnkStruct_x20 * x20, u8 count); +static void BlankUnkStruct_x1CArray(struct UnkStruct_x1C * x1C, u8 count); +static bool8 AreGnameUnameDifferent(struct UnionGnameUnamePair * arg0, const struct UnionGnameUnamePair * arg1); +static bool32 AreUnionRoomPlayerGnamesDifferent(struct UnionGnameUnamePair * arg0, struct UnionGnameUnamePair * arg1); +static u32 Findx20Inx1CArray(struct UnkStruct_x20 * x20, struct UnkStruct_x1C * x1Carr); +static u8 Appendx1Ctox20(struct UnkStruct_x20 * x20arr, struct UnkStruct_x1C * x1C, u8 count); +static void PrintUnionRoomGroupOnWindow(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id); +static void PrintGroupMemberCandidateOnWindowWithColor(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id); +static bool32 PlayerIsTalkingToUnionRoomAide(void); +static u32 GetResponseIdx_InviteToURoomActivity(s32 activity); +static u32 ConvPartnerUnameAndGetWhetherMetAlready(struct UnkStruct_x20 * unkX20); +static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, u8 overrideGender, u8 playerIdx, u32 playerGender); static void nullsub_92(u8 windowId, s32 itemId, u8 y); -static void sub_811ACA4(u8 windowId, s32 itemId, u8 y); -static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1); -static s32 GetUnionRoomPlayerGender(s32 a0, struct UnkStruct_Main0 * a1); -static s32 sub_811ADD0(u32 type, u32 species); -static void sub_811AE68(u8 *dst, s32 arg1, u32 playerGender); -static void sub_811AECC(u8 *dst, u8 arg1); -static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * arg3); -static bool32 sub_811B0A4(struct UnkStruct_URoom * arg0); +static void TradeBoardListMenuItemPrintFunc(u8 windowId, s32 itemId, u8 y); +static s32 GetIndexOfNthTradeBoardOffer(struct UnkStruct_x20 * x20, s32 n); +static s32 GetUnionRoomPlayerGender(s32 playerIdx, struct UnkStruct_Main0 * main0); +static s32 IsRequestedTypeAndSpeciesInPlayerParty(u32 type, u32 species); +static void GetURoomActivityRejectMsg(u8 *dst, s32 activity, u32 playerGender); +static void GetURoomActivityStartMsg(u8 *dst, u8 activity); +static s32 GetChatLeaderActionRequestMessage(u8 *dst, u32 gender, u16 *activity_p, struct UnkStruct_URoom * uroom); +static bool32 PollPartnerYesNoResponse(struct UnkStruct_URoom * uroom); static bool32 HasAtLeastTwoMonsOfLevel30OrLower(void); static void ResetUnionRoomTrade(struct UnionRoomTrade * trade); static bool32 RegisterTradeMonAndGetIsEgg(u32 monId, struct UnionRoomTrade * trade); static void RegisterTradeMon(u32 monId, struct UnionRoomTrade * trade); static u32 GetPartyPositionOfRegisteredMon(struct UnionRoomTrade * trade, u8 mpId); -static void sub_811B258(bool32 a0); -static void sub_811B298(void); -static u8 sub_811B2A8(s32 a0); -static u8 sub_811B2D8(struct UnkStruct_URoom * arg0); -static void sub_811B31C(u8 *dest, struct UnkStruct_URoom * uRoom, bool8 gender); +static void HandleCancelTrade(bool32 unlockObjs); +static void UR_EnableScriptContext2AndFreezeObjectEvents(void); +static u8 GetSinglePartnerSpriteGenderParam(s32 linkPlayer); +static u8 GetActivePartnerSpriteGenderParam(struct UnkStruct_URoom * uroom); +static void ViewURoomPartnerTrainerCard(u8 *dest, struct UnkStruct_URoom * uRoom, bool8 parent_child); #define _8456CD8(a, b) ((a) | ((b) << 8)) -static const u8 *const gUnknown_8456C74[] = { - gUnknown_84571AC, - gUnknown_8459394, - gUnknown_84593A4, - gUnknown_84593B4, - gUnknown_84593C4, - gUnknown_84593D4, - gUnknown_84593E4, - gUnknown_84593F4, - gUnknown_84593DC, - gUnknown_8459400, - gUnknown_8459410, - gUnknown_845941C, - gUnknown_845942C, - gUnknown_8459434, - gUnknown_8459440, - gUnknown_84571AC, - gUnknown_84571AC, - gUnknown_84571AC, - gUnknown_84571AC, - gUnknown_84571AC, - gUnknown_84571AC, - gUnknown_84593E4, - gUnknown_84593F4 +static const u8 *const sUnionRoomActivityStringPtrs[] = { + gUnionRoomActivity_Blank, + gUnionRoomActivity_SingleBattle, + gUnionRoomActivity_DoubleBattle, + gUnionRoomActivity_MultiBattle, + gUnionRoomActivity_PokemonTrades, + gUnionRoomActivity_Chat, + gUnionRoomActivity_WonderCards, + gunionRoomActivity_WonderNews, + gUnionRoomActivity_Cards, + gUnionRoomActivity_PokemonJump, + gUnionRoomActivity_BerryCrush, + gUnionRoomActivity_BerryPicking, + gUnionRoomActivity_Search, + gUnionRoomActivity_SpinTradeJP, + gUnionRoomActivity_ItemTradeJP, + gUnionRoomActivity_Blank, + gUnionRoomActivity_Blank, + gUnionRoomActivity_Blank, + gUnionRoomActivity_Blank, + gUnionRoomActivity_Blank, + gUnionRoomActivity_Blank, + gUnionRoomActivity_WonderCards, + gunionRoomActivity_WonderNews }; -static const struct WindowTemplate gUnknown_8456CD0 = { +static const struct WindowTemplate sWindowTemplate_BButtonCancel = { .bg = 0, .tilemapLeft = 0, .tilemapTop = 0, @@ -166,19 +168,19 @@ static const struct WindowTemplate gUnknown_8456CD0 = { .baseBlock = 0x008 }; -static const u32 gUnknown_8456CD8[] = { - _8456CD8( 1, 2), - _8456CD8( 2, 2), - _8456CD8( 3, 4), - _8456CD8( 4, 2), - _8456CD8( 9, 37), - _8456CD8(10, 37), - _8456CD8(11, 53), - _8456CD8(13, 53), - _8456CD8(14, 53) +static const u32 sLinkGroupToActivityAndCapacity[] = { + [LINK_GROUP_SINGLE_BATTLE] = _8456CD8(ACTIVITY_BATTLE, 2), + [LINK_GROUP_DOUBLE_BATTLE] = _8456CD8(ACTIVITY_DBLBATTLE, 2), + [LINK_GROUP_MULTI_BATTLE] = _8456CD8(ACTIVITY_MLTBATTLE, 4), + [LINK_GROUP_TRADE] = _8456CD8(ACTIVITY_TRADE, 2), + [LINK_GROUP_POKEMON_JUMP] = _8456CD8(ACTIVITY_PJUMP, 5 | 0x20), + [LINK_GROUP_BERRY_CRUSH] = _8456CD8(ACTIVITY_BCRUSH, 5 | 0x20), + [LINK_GROUP_BERRY_PICKING] = _8456CD8(ACTIVITY_BPICK, 5 | 0x30), + [LINK_GROUP_WONDER_CARD] = _8456CD8(ACTIVITY_SPINTRADE, 5 | 0x30), + [LINK_GROUP_WONDER_NEWS] = _8456CD8(ACTIVITY_ITEMTRADE, 5 | 0x30) }; -static const struct WindowTemplate gUnknown_8456CFC = { +static const struct WindowTemplate sWindowTemplate_List_PossibleGroupMembers = { .bg = 0, .tilemapLeft = 1, .tilemapTop = 3, @@ -188,7 +190,7 @@ static const struct WindowTemplate gUnknown_8456CFC = { .baseBlock = 0x044 }; -static const struct WindowTemplate gUnknown_8456D04 = { +static const struct WindowTemplate sWindowTemplate_NumPlayerMode = { .bg = 0, .tilemapLeft = 16, .tilemapTop = 3, @@ -198,18 +200,18 @@ static const struct WindowTemplate gUnknown_8456D04 = { .baseBlock = 0x0C6 }; -const struct ListMenuItem gUnknown_8456D0C[] = { - {gUnknown_84571AC, 0}, - {gUnknown_84571AC, 1}, - {gUnknown_84571AC, 2}, - {gUnknown_84571AC, 3}, - {gUnknown_84571AC, 4} +const struct ListMenuItem sListMenuItems_PossibleGroupMembers[] = { + {gUnionRoomActivity_Blank, 0}, + {gUnionRoomActivity_Blank, 1}, + {gUnionRoomActivity_Blank, 2}, + {gUnionRoomActivity_Blank, 3}, + {gUnionRoomActivity_Blank, 4} }; -static const struct ListMenuTemplate gUnknown_8456D34 = { - .items = gUnknown_8456D0C, +static const struct ListMenuTemplate sListMenuTemplate_PossibleGroupMembers = { + .items = sListMenuItems_PossibleGroupMembers, .moveCursorFunc = NULL, - .itemPrintFunc = sub_81164C8, + .itemPrintFunc = ItemPrintFunc_PossibleGroupMembers, .totalItems = 5, .maxShowed = 5, .windowId = 0, @@ -227,7 +229,7 @@ static const struct ListMenuTemplate gUnknown_8456D34 = { .cursorKind = 1 }; -static const struct WindowTemplate gUnknown_8456D4C = { +static const struct WindowTemplate sWindowTemplate_MysteryGiftList = { .bg = 0, .tilemapLeft = 1, .tilemapTop = 3, @@ -237,7 +239,7 @@ static const struct WindowTemplate gUnknown_8456D4C = { .baseBlock = 0x044 }; -static const struct WindowTemplate gUnknown_8456D54 = { +static const struct WindowTemplate sWindowTemplate_MysteryGiftPlayerNameAndId = { .bg = 0, .tilemapLeft = 20, .tilemapTop = 3, @@ -247,29 +249,29 @@ static const struct WindowTemplate gUnknown_8456D54 = { .baseBlock = 0x0EE }; -static const struct ListMenuItem gUnknown_8456D5C[] = { - {gUnknown_84571AC, 0}, - {gUnknown_84571AC, 1}, - {gUnknown_84571AC, 2}, - {gUnknown_84571AC, 3}, - {gUnknown_84571AC, 4}, - {gUnknown_84571AC, 5}, - {gUnknown_84571AC, 6}, - {gUnknown_84571AC, 7}, - {gUnknown_84571AC, 8}, - {gUnknown_84571AC, 9}, - {gUnknown_84571AC, 10}, - {gUnknown_84571AC, 11}, - {gUnknown_84571AC, 12}, - {gUnknown_84571AC, 13}, - {gUnknown_84571AC, 14}, - {gUnknown_84571AC, 15} +static const struct ListMenuItem sListMenuItems_UnionRoomGroups[] = { + {gUnionRoomActivity_Blank, 0}, + {gUnionRoomActivity_Blank, 1}, + {gUnionRoomActivity_Blank, 2}, + {gUnionRoomActivity_Blank, 3}, + {gUnionRoomActivity_Blank, 4}, + {gUnionRoomActivity_Blank, 5}, + {gUnionRoomActivity_Blank, 6}, + {gUnionRoomActivity_Blank, 7}, + {gUnionRoomActivity_Blank, 8}, + {gUnionRoomActivity_Blank, 9}, + {gUnionRoomActivity_Blank, 10}, + {gUnionRoomActivity_Blank, 11}, + {gUnionRoomActivity_Blank, 12}, + {gUnionRoomActivity_Blank, 13}, + {gUnionRoomActivity_Blank, 14}, + {gUnionRoomActivity_Blank, 15} }; -static const struct ListMenuTemplate gUnknown_8456DDC = { - .items = gUnknown_8456D5C, +static const struct ListMenuTemplate sListMenuTemplate_UnionRoomGroups = { + .items = sListMenuItems_UnionRoomGroups, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, - .itemPrintFunc = sub_8116F94, + .itemPrintFunc = ListMenuItemPrintFunc_UnionRoomGroups, .totalItems = 16, .maxShowed = 5, .windowId = 0, @@ -287,7 +289,7 @@ static const struct ListMenuTemplate gUnknown_8456DDC = { .cursorKind = 0 }; -static const struct WindowTemplate gUnknown_8456DF4 = { +static const struct WindowTemplate sWindowTemplate_InviteToActivity = { .bg = 0, .tilemapLeft = 20, .tilemapTop = 6, @@ -297,15 +299,15 @@ static const struct WindowTemplate gUnknown_8456DF4 = { .baseBlock = 0x001 }; -static const struct ListMenuItem gUnknown_8456DFC[] = { - {gUnknown_8459354, _8456CD8( 8, 2)}, - {gUnknown_8459344, _8456CD8(65, 2)}, - {gUnknown_845934C, _8456CD8(69, 2)}, - {gUnknown_8459360, _8456CD8(64, 0)} +static const struct ListMenuItem sListMenuItems_InviteToActivity[] = { + {gUnknown_8459354, _8456CD8( ACTIVITY_CARD, 2)}, + {gUnknown_8459344, _8456CD8(ACTIVITY_BATTLE | IN_UNION_ROOM, 2)}, + {gUnknown_845934C, _8456CD8(ACTIVITY_CHAT | IN_UNION_ROOM, 2)}, + {gUnknown_8459360, _8456CD8(ACTIVITY_NONE | IN_UNION_ROOM, 0)} }; -static const struct ListMenuTemplate gUnknown_8456E1C = { - .items = gUnknown_8456DFC, +static const struct ListMenuTemplate sListMenuTemplate_InviteToActivity = { + .items = sListMenuItems_InviteToActivity, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, .totalItems = 4, @@ -325,7 +327,7 @@ static const struct ListMenuTemplate gUnknown_8456E1C = { .cursorKind = 0 }; -static const struct WindowTemplate gUnknown_8456E34 = { +static const struct WindowTemplate sWindowTemplate_TradeBoardRegisterInfoExit = { .bg = 0, .tilemapLeft = 18, .tilemapTop = 8, @@ -341,7 +343,7 @@ static const struct ListMenuItem gUnknown_8456E3C[] = { {gUnknown_8459360, 3} }; -static const struct ListMenuTemplate gUnknown_8456E54 = { +static const struct ListMenuTemplate sListMenuTemplate_TradeBoardRegisterInfoExit = { .items = gUnknown_8456E3C, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -362,7 +364,7 @@ static const struct ListMenuTemplate gUnknown_8456E54 = { .cursorKind = 0 }; -static const struct WindowTemplate gUnknown_8456E6C = { +static const struct WindowTemplate sWindowTemplate_TypeNames = { .bg = 0, .tilemapLeft = 20, .tilemapTop = 2, @@ -372,7 +374,7 @@ static const struct WindowTemplate gUnknown_8456E6C = { .baseBlock = 0x001 }; -static const struct ListMenuItem gUnknown_8456E74[] = { +static const struct ListMenuItem sListMenuItems_TypeNames[] = { {gTypeNames[TYPE_NORMAL], TYPE_NORMAL}, {gTypeNames[TYPE_FIRE], TYPE_FIRE}, {gTypeNames[TYPE_WATER], TYPE_WATER}, @@ -393,8 +395,8 @@ static const struct ListMenuItem gUnknown_8456E74[] = { {gUnknown_8459360, NUMBER_OF_MON_TYPES} }; -static const struct ListMenuTemplate gUnknown_8456F04 = { - .items = gUnknown_8456E74, +static const struct ListMenuTemplate sListMenuTemplate_TypeNames = { + .items = sListMenuItems_TypeNames, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, .totalItems = NUMBER_OF_MON_TYPES, @@ -414,7 +416,7 @@ static const struct ListMenuTemplate gUnknown_8456F04 = { .cursorKind = 0 }; -static const struct WindowTemplate gUnknown_8456F1C = { +static const struct WindowTemplate sTradeBoardWindowTemplate = { .bg = 0, .tilemapLeft = 1, .tilemapTop = 1, @@ -434,23 +436,23 @@ static const struct WindowTemplate gUnknown_8456F24 = { .baseBlock = 0x039 }; -static const struct ListMenuItem gUnknown_8456F2C[] = { - {gUnknown_84571AC, -3}, - {gUnknown_84571AC, 0}, - {gUnknown_84571AC, 1}, - {gUnknown_84571AC, 2}, - {gUnknown_84571AC, 3}, - {gUnknown_84571AC, 4}, - {gUnknown_84571AC, 5}, - {gUnknown_84571AC, 6}, - {gUnknown_84571AC, 7}, +static const struct ListMenuItem sTradeBoardListMenuItems[] = { + {gUnionRoomActivity_Blank, -3}, + {gUnionRoomActivity_Blank, 0}, + {gUnionRoomActivity_Blank, 1}, + {gUnionRoomActivity_Blank, 2}, + {gUnionRoomActivity_Blank, 3}, + {gUnionRoomActivity_Blank, 4}, + {gUnionRoomActivity_Blank, 5}, + {gUnionRoomActivity_Blank, 6}, + {gUnionRoomActivity_Blank, 7}, {gUnknown_8459368, 8} }; -static const struct ListMenuTemplate gUnknown_8456F7C = { - .items = gUnknown_8456F2C, +static const struct ListMenuTemplate sTradeBoardListMenuTemplate = { + .items = sTradeBoardListMenuItems, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, - .itemPrintFunc = sub_811ACA4, + .itemPrintFunc = TradeBoardListMenuItemPrintFunc, .totalItems = 10, .maxShowed = 5, .windowId = 0, @@ -479,22 +481,22 @@ static const struct WindowTemplate gUnknown_8456F94 = { }; static const struct ListMenuItem gUnknown_8456F9C[] = { - {gUnknown_84571AC, 0}, - {gUnknown_84571AC, 1}, - {gUnknown_84571AC, 2}, - {gUnknown_84571AC, 3}, - {gUnknown_84571AC, 4}, - {gUnknown_84571AC, 5}, - {gUnknown_84571AC, 6}, - {gUnknown_84571AC, 7}, - {gUnknown_84571AC, 8}, - {gUnknown_84571AC, 9}, - {gUnknown_84571AC, 10}, - {gUnknown_84571AC, 11}, - {gUnknown_84571AC, 12}, - {gUnknown_84571AC, 13}, - {gUnknown_84571AC, 14}, - {gUnknown_84571AC, 15} + {gUnionRoomActivity_Blank, 0}, + {gUnionRoomActivity_Blank, 1}, + {gUnionRoomActivity_Blank, 2}, + {gUnionRoomActivity_Blank, 3}, + {gUnionRoomActivity_Blank, 4}, + {gUnionRoomActivity_Blank, 5}, + {gUnionRoomActivity_Blank, 6}, + {gUnionRoomActivity_Blank, 7}, + {gUnionRoomActivity_Blank, 8}, + {gUnionRoomActivity_Blank, 9}, + {gUnionRoomActivity_Blank, 10}, + {gUnionRoomActivity_Blank, 11}, + {gUnionRoomActivity_Blank, 12}, + {gUnionRoomActivity_Blank, 13}, + {gUnionRoomActivity_Blank, 14}, + {gUnionRoomActivity_Blank, 15} }; static const struct ListMenuTemplate gUnknown_845701C = { @@ -518,54 +520,138 @@ static const struct ListMenuTemplate gUnknown_845701C = { .cursorKind = 0 }; -static const struct UnkStruct_Shared gUnknown_8457034 = {}; +static const struct UnionGnameUnamePair sUnionGnameUnamePair_Dummy = {}; // starts at gUnknown_082F0474 in pokeemerald, union link groups -ALIGNED(4) static const u8 gUnknown_845704C[] = {0x01, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457050[] = {0x02, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457054[] = {0x03, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457058[] = {0x04, 0xFF}; -ALIGNED(4) static const u8 gUnknown_845705C[] = {0x09, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457060[] = {0x0A, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457064[] = {0x0B, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457068[] = {0x15, 0xFF}; -ALIGNED(4) static const u8 gUnknown_845706C[] = {0x16, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457070[] = {0x40, 0x41, 0x44, 0x45, 0x48, 0x51, 0x52, 0x53, 0x54, 0xFF}; -ALIGNED(4) static const u8 gUnknown_845707C[] = {0x0C, 0xFF}; -ALIGNED(4) static const u8 gUnknown_8457080[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B, 0x15, 0x16, 0x0D, 0xFF}; -ALIGNED(4) static const u8 gUnknown_845708C[] = {0x01, 0x02, 0x03, 0x04, 0x0A, 0xFF}; - -static const u8 *const gUnknown_8457094[] = { - gUnknown_845704C, - gUnknown_8457050, - gUnknown_8457054, - gUnknown_8457058, - gUnknown_845705C, - gUnknown_8457060, - gUnknown_8457064, - gUnknown_8457068, - gUnknown_845706C, - gUnknown_8457070, - gUnknown_845707C, - gUnknown_8457080, - gUnknown_845708C +ALIGNED(4) static const u8 gUnknown_845704C[] = { + ACTIVITY_BATTLE, + 0xFF }; -static const u8 gUnknown_84570C8[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B, 0x15, 0x16, 0xF7, 0x00, 0xAF, 0xF7, 0x01, 0xFF, 0x00}; +ALIGNED(4) static const u8 gUnknown_8457050[] = { + ACTIVITY_DBLBATTLE, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457054[] = { + ACTIVITY_MLTBATTLE, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457058[] = { + ACTIVITY_TRADE, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_845705C[] = { + ACTIVITY_PJUMP, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457060[] = { + ACTIVITY_BCRUSH, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457064[] = { + ACTIVITY_BPICK, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457068[] = { + ACTIVITY_WCARD2, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_845706C[] = { + ACTIVITY_WNEWS2, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457070[] = { + ACTIVITY_NONE | IN_UNION_ROOM, + ACTIVITY_BATTLE | IN_UNION_ROOM, + ACTIVITY_TRADE | IN_UNION_ROOM, + ACTIVITY_CHAT | IN_UNION_ROOM, + ACTIVITY_CARD | IN_UNION_ROOM, + ACTIVITY_ACCEPT | IN_UNION_ROOM, + ACTIVITY_DECLINE | IN_UNION_ROOM, + ACTIVITY_NPCTALK | IN_UNION_ROOM, + ACTIVITY_PLYRTALK | IN_UNION_ROOM, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_845707C[] = { + ACTIVITY_SEARCH, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_8457080[] = { + ACTIVITY_BATTLE, + ACTIVITY_DBLBATTLE, + ACTIVITY_MLTBATTLE, + ACTIVITY_TRADE, + ACTIVITY_PJUMP, + ACTIVITY_BCRUSH, + ACTIVITY_BPICK, + ACTIVITY_WCARD2, + ACTIVITY_WNEWS2, + ACTIVITY_SPINTRADE, + 0xFF +}; + +ALIGNED(4) static const u8 gUnknown_845708C[] = { + ACTIVITY_BATTLE, + ACTIVITY_DBLBATTLE, + ACTIVITY_MLTBATTLE, + ACTIVITY_TRADE, + ACTIVITY_BCRUSH, + 0xFF +}; + +static const u8 *const sAcceptedActivityIds[] = { + [LINK_GROUP_SINGLE_BATTLE] = gUnknown_845704C, + [LINK_GROUP_DOUBLE_BATTLE] = gUnknown_8457050, + [LINK_GROUP_MULTI_BATTLE] = gUnknown_8457054, + [LINK_GROUP_TRADE] = gUnknown_8457058, + [LINK_GROUP_POKEMON_JUMP] = gUnknown_845705C, + [LINK_GROUP_BERRY_CRUSH] = gUnknown_8457060, + [LINK_GROUP_BERRY_PICKING] = gUnknown_8457064, + [LINK_GROUP_WONDER_CARD] = gUnknown_8457068, + [LINK_GROUP_WONDER_NEWS] = gUnknown_845706C, + [9] = gUnknown_8457070, + [10] = gUnknown_845707C, + [11] = gUnknown_8457080, + [12] = gUnknown_845708C +}; + +static const u8 sLinkGroupToURoomActivity[] = { + [LINK_GROUP_SINGLE_BATTLE] = ACTIVITY_BATTLE, + [LINK_GROUP_DOUBLE_BATTLE] = ACTIVITY_DBLBATTLE, + [LINK_GROUP_MULTI_BATTLE] = ACTIVITY_MLTBATTLE, + [LINK_GROUP_TRADE] = ACTIVITY_TRADE, + [LINK_GROUP_POKEMON_JUMP] = ACTIVITY_PJUMP, + [LINK_GROUP_BERRY_CRUSH] = ACTIVITY_BCRUSH, + [LINK_GROUP_BERRY_PICKING] = ACTIVITY_BPICK, + [LINK_GROUP_WONDER_CARD] = ACTIVITY_WCARD2, + [LINK_GROUP_WONDER_NEWS] = ACTIVITY_WNEWS2 +}; + +static const u8 sUnref_84570D1[] = _("{DYNAMIC 00}·{DYNAMIC 01}"); #undef _8456CD8 // These are functions in Emerald but inlined in FireRed -#define IntlConvPartnerUname7(dest, arg1) ({ \ - StringCopy7(dest, (arg1).unk.playerName); \ - ConvertInternationalString(dest, (arg1).unk.gname.unk_00.unk_00_0); \ +#define IntlConvPartnerUname7(dest, arg1) ({ \ + StringCopy7(dest, (arg1).gname_uname.uname); \ + ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \ }) -#define IntlConvPartnerUname(dest, arg1) ({ \ - StringCopy(dest, (arg1).unk.playerName); \ - ConvertInternationalString(dest, (arg1).unk.gname.unk_00.unk_00_0); \ +#define IntlConvPartnerUname(dest, arg1) ({ \ + StringCopy(dest, (arg1).gname_uname.uname); \ + ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \ }) #define CopyTrainerCardData(dest, src, _version) ({ \ @@ -578,47 +664,56 @@ static const u8 gUnknown_84570C8[] = {0x01, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x0B, _maxWidth - strWidth; \ }) -static void sub_811586C(u8 windowId, u8 arg1, u8 stringId) +// capacityCode is a 2-nybble code +// Bits 0-3: Capacity +// Bits 4-7: Min required (if 0, must have exactly Capacity players +static void PrintNumPlayersWaitingForMsg(u8 windowId, u8 capacityCode, u8 count) { FillWindowPixelBuffer(windowId, PIXEL_FILL(1)); - switch (arg1 << 8) + switch (capacityCode << 8) { case 0x200: - sub_811A444(windowId, 2, gUnknown_845742C[0][stringId - 1], 0, 2, 0); + UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[0][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE); break; case 0x400: - sub_811A444(windowId, 2, gUnknown_845742C[1][stringId - 1], 0, 2, 0); + UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[1][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE); break; case 0x2500: - sub_811A444(windowId, 2, gUnknown_845742C[2][stringId - 1], 0, 2, 0); + UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[2][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE); break; case 0x3500: - sub_811A444(windowId, 2, gUnknown_845742C[3][stringId - 1], 0, 2, 0); + UR_AddTextPrinterParameterized(windowId, 2, gUnknown_845742C[3][count - 1], 0, 2, UR_COLOR_DKE_WHT_LTE); break; } CopyWindowToVram(windowId, 2); } -static void sub_8115924(u8 windowId) +static void PrintPlayerNameAndIdOnWindow(u8 windowId) { u8 text[12]; u8 text2[12]; - sub_811A444(windowId, 2, gSaveBlock2Ptr->playerName, 0, 2, 0); + UR_AddTextPrinterParameterized(windowId, 2, gSaveBlock2Ptr->playerName, 0, 2, UR_COLOR_DKE_WHT_LTE); StringCopy(text2, gUnknown_84571B4); ConvertIntToDecimalStringN(text, ReadAsU16(gSaveBlock2Ptr->playerTrainerId), STR_CONV_MODE_LEADING_ZEROS, 5); StringAppend(text2, text); - sub_811A444(windowId, 0, text2, 0, 0x10, 0); + UR_AddTextPrinterParameterized(windowId, 0, text2, 0, 0x10, UR_COLOR_DKE_WHT_LTE); } -static void sub_811599C(u8 *dst, u8 caseId) +static void StringExpandPlaceholders_AwaitingCommFromAnother(u8 *dst, u8 caseId) { switch (caseId) { - case 1 ... 4: - case 9 ... 11: - case 21 ... 22: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_TRADE: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: + case ACTIVITY_WCARD2: + case ACTIVITY_WNEWS2: // UB: argument *dst isn't used, instead it always prints to gStringVar4 StringExpandPlaceholders(gStringVar4, gUnknown_8457234); break; @@ -630,7 +725,7 @@ void TryBecomeLinkLeader(void) u8 taskId; struct UnkStruct_Leader * dataPtr; - taskId = CreateTask(sub_8115A68, 0); + taskId = CreateTask(Task_TryBecomeLinkLeader, 0); sUnionRoomMain.leader = dataPtr = (void*)(gTasks[taskId].data); sLeader = dataPtr; @@ -639,7 +734,7 @@ void TryBecomeLinkLeader(void) gSpecialVar_Result = 0; } -static void sub_8115A68(u8 taskId) +static void Task_TryBecomeLinkLeader(u8 taskId) { u32 id, val; struct UnkStruct_Leader * data = sUnionRoomMain.leader; @@ -647,63 +742,63 @@ static void sub_8115A68(u8 taskId) switch (data->state) { case 0: - gUnknown_203B058 = gUnknown_8456CD8[gSpecialVar_0x8004]; - gUnknown_203B059 = gUnknown_8456CD8[gSpecialVar_0x8004] >> 8; - SetHostRFUtgtGname(gUnknown_203B058, 0, 0); - sub_800B1F4(); + sPlayerCurrActivity = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004]; + sPlayerActivityGroupSize = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004] >> 8; + SetHostRFUtgtGname(sPlayerCurrActivity, 0, 0); + SetWirelessCommType1(); OpenLink(); - sub_80FBB8C(gUnknown_203B059 & 0xF); + InitializeRfuLinkManager_LinkLeader(sPlayerActivityGroupSize & 0xF); data->state = 3; break; case 3: data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - data->field_0 = AllocZeroed(5 * sizeof(struct UnkStruct_x20)); - data->field_8 = AllocZeroed(5 * sizeof(struct UnkStruct_x20)); - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 5); - LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].unk.gname, data->field_0->arr[0].unk.playerName); + data->field_0 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20)); + data->field_8 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20)); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_PARTY_SIZE); + LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].gname_uname.gname, data->field_0->arr[0].gname_uname.uname); data->field_0->arr[0].field_18 = 0; - data->field_0->arr[0].field_1A_0 = 1; + data->field_0->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN; data->field_0->arr[0].field_1A_1 = 0; data->field_0->arr[0].field_1B = 0; - data->field_17 = sub_811A054(data->field_4, 0xFF); - data->field_10 = AddWindow(&gUnknown_8456CD0); - data->listWindowId = AddWindow(&gUnknown_8456CFC); - data->field_11 = AddWindow(&gUnknown_8456D04); + data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF); + data->bButtonCancelWindowId = AddWindow(&sWindowTemplate_BButtonCancel); + data->listWindowId = AddWindow(&sWindowTemplate_List_PossibleGroupMembers); + data->nPlayerModeWindowId = AddWindow(&sWindowTemplate_NumPlayerMode); - FillWindowPixelBuffer(data->field_10, PIXEL_FILL(2)); - sub_811A444(data->field_10, 0, gUnknown_845747C, 8, 2, 4); - PutWindowTilemap(data->field_10); - CopyWindowToVram(data->field_10, 2); + FillWindowPixelBuffer(data->bButtonCancelWindowId, PIXEL_FILL(2)); + UR_AddTextPrinterParameterized(data->bButtonCancelWindowId, 0, gUnknown_845747C, 8, 2, UR_COLOR_WHT_DKE_LTE); + PutWindowTilemap(data->bButtonCancelWindowId); + CopyWindowToVram(data->bButtonCancelWindowId, 2); DrawStdWindowFrame(data->listWindowId, FALSE); - gMultiuseListMenuTemplate = gUnknown_8456D34; + gMultiuseListMenuTemplate = sListMenuTemplate_PossibleGroupMembers; gMultiuseListMenuTemplate.windowId = data->listWindowId; data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); - DrawStdWindowFrame(data->field_11, FALSE); - PutWindowTilemap(data->field_11); - CopyWindowToVram(data->field_11, 2); + DrawStdWindowFrame(data->nPlayerModeWindowId, FALSE); + PutWindowTilemap(data->nPlayerModeWindowId); + CopyWindowToVram(data->nPlayerModeWindowId, 2); CopyBgTilemapBufferToVram(0); - data->field_13 = 1; + data->playerCount = 1; data->state = 4; break; case 4: - StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]); - if ((gUnknown_203B059 >> 4) != 0) + StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]); + if ((sPlayerActivityGroupSize >> 4) != 0) { - if (data->field_13 > (gUnknown_203B059 >> 4) - 1 && (gUnknown_203B059 & 0xF) != 0) + if (data->playerCount > (sPlayerActivityGroupSize >> 4) - 1 && (sPlayerActivityGroupSize & 0xF) != 0) StringExpandPlaceholders(gStringVar4, gUnknown_8457264); else StringExpandPlaceholders(gStringVar4, gUnknown_8457234); } else { - sub_811599C(gStringVar4, gUnknown_203B058); + StringExpandPlaceholders_AwaitingCommFromAnother(gStringVar4, sPlayerCurrActivity); } - sub_811586C(data->field_11, gUnknown_203B059, data->field_13); + PrintNumPlayersWaitingForMsg(data->nPlayerModeWindowId, sPlayerActivityGroupSize, data->playerCount); data->state = 5; break; case 5: @@ -711,24 +806,24 @@ static void sub_8115A68(u8 taskId) data->state = 6; break; case 6: - sub_8116444(data, 7, 10); + Leader_SetStateIfMemberListChanged(data, 7, 10); if (JOY_NEW(B_BUTTON)) { - if (data->field_13 == 1) + if (data->playerCount == 1) data->state = 23; - else if ((gUnknown_203B059 & 0xF0) != 0) + else if ((sPlayerActivityGroupSize & 0xF0) != 0) data->state = 30; else data->state = 19; } - if ((gUnknown_203B059 >> 4) != 0 - && data->field_13 > (gUnknown_203B059 >> 4) - 1 - && (gUnknown_203B059 & 0xF) != 0 + if ((sPlayerActivityGroupSize >> 4) != 0 + && data->playerCount > (sPlayerActivityGroupSize >> 4) - 1 + && (sPlayerActivityGroupSize & 0xF) != 0 && sub_80FC1CC() && JOY_NEW(START_BUTTON)) { data->state = 15; - sub_80F8F5C(); + LinkRfu_StopManagerAndFinalizeSlots(); } if (data->state == 6 && sub_80FA5D4()) { @@ -739,20 +834,21 @@ static void sub_8115A68(u8 taskId) if (!sub_80FA5D4()) { data->state = 6; - data->field_13 = sub_81165E8(data->field_0); + data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0); } break; case 10: - id = ((gUnknown_203B058 & 0xF) == 2) ? 1 : 0; + id = ((sPlayerCurrActivity & 0xF) == 2) ? 1 : 0; if (PrintOnTextbox(&data->textState, gUnknown_845767C[id])) { - data->field_13 = sub_81165E8(data->field_0); + data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); data->state = 4; } break; case 29: - id = ((gUnknown_203B059 & 0xF) == 2) ? 0 : 1; + // Other player cancelled. + id = ((sPlayerActivityGroupSize & 0xF) == 2) ? 0 : 1; if (PrintOnTextbox(&data->textState, gUnknown_845767C[id])) { data->state = 21; @@ -765,19 +861,19 @@ static void sub_8115A68(u8 taskId) } break; case 11: - switch (sub_811A14C(&data->textState, sub_80FA634(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName))) + switch (UnionRoomHandleYesNo(&data->textState, TrainerIdAndNameStillInPartnersList(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname))) { case 0: LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); data->field_19 = 5; - sub_80FA670(5, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 12; break; case 1: case -1: data->field_19 = 6; - sub_80FA670(6, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 12; break; case -3: @@ -786,29 +882,31 @@ static void sub_8115A68(u8 taskId) } break; case 12: - val = sub_80FA6FC(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); if (val == 1) { + // Xfer complete if (data->field_19 == 5) { - data->field_0->arr[data->field_13].field_1B = 0; + // Sent "OK" + data->field_0->arr[data->playerCount].field_1B = 0; RedrawListMenu(data->listTaskId); - data->field_13++; - if (data->field_13 == (gUnknown_203B059 & 0xF)) + data->playerCount++; + if (data->playerCount == (sPlayerActivityGroupSize & 0xF)) { - if ((gUnknown_203B059 & 0xF0) != 0 || data->field_13 == 4) + if ((sPlayerActivityGroupSize & 0xF0) != 0 || data->playerCount == 4) { data->state = 15; } else { - IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_13 - 1]); + IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->playerCount - 1]); StringExpandPlaceholders(gStringVar4, gUnknown_8457554); data->state = 13; } - sub_80F8F5C(); - sub_811586C(data->field_11, gUnknown_203B059, data->field_13); + LinkRfu_StopManagerAndFinalizeSlots(); + PrintNumPlayersWaitingForMsg(data->nPlayerModeWindowId, sPlayerActivityGroupSize, data->playerCount); } else { @@ -817,9 +915,10 @@ static void sub_8115A68(u8 taskId) } else { - sub_80FBD4C(data->field_0->arr[data->field_13].unk.playerName, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId)); - data->field_0->arr[data->field_13].field_1A_0 = 0; - sub_81165E8(data->field_0); + // Sent "no" + RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId)); + data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; + UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); data->state = 4; } @@ -828,7 +927,8 @@ static void sub_8115A68(u8 taskId) } else if (val == 2) { - sub_80FB9E4(0, 0); + // Disconnect + RfuSetErrorStatus(0, 0); data->state = 4; } break; @@ -837,22 +937,25 @@ static void sub_8115A68(u8 taskId) data->state = 14; break; case 14: - if (++data->field_E > 120) + if (++data->delayTimerAfterOk > 120) data->state = 17; break; case 15: + // Are these members OK? if (PrintOnTextbox(&data->textState, gUnknown_8457514)) data->state = 16; break; case 16: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: + // Yes data->state = 17; break; case 1: case -1: - if ((gUnknown_203B059 & 0xF0) != 0) + // No + if ((sPlayerActivityGroupSize & 0xF0) != 0) data->state = 30; else data->state = 19; @@ -864,16 +967,16 @@ static void sub_8115A68(u8 taskId) data->state = 20; break; case 20: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: data->state = 23; break; case 1: case -1: - if ((gUnknown_203B059 & 0xF0) != 0) + if ((sPlayerActivityGroupSize & 0xF0) != 0) data->state = 15; - else if (data->field_13 == (gUnknown_203B059 & 0xF)) + else if (data->playerCount == (sPlayerActivityGroupSize & 0xF)) data->state = 15; else data->state = 4; @@ -881,13 +984,15 @@ static void sub_8115A68(u8 taskId) } break; case 17: - if (!sub_8116444(data, 7, 23)) + // Go to start + // Final membership check + if (!Leader_SetStateIfMemberListChanged(data, 7, 23)) data->state = 18; break; case 18: - if (sub_80F8F40()) + if (LmanAcceptSlotFlagIsNotZero()) { - if (sub_80F8F7C(FALSE)) + if (WaitRfuState(FALSE)) { data->state = 26; } @@ -899,14 +1004,16 @@ static void sub_8115A68(u8 taskId) } break; case 30: + // Mode with members will be canceled. if (PrintOnTextbox(&data->textState, gUnknown_8457610)) data->state = 23; break; case 21: case 23: + // An error occurred. Please start over from the beginning. DestroyWirelessStatusIndicatorSprite(); - sub_80F8DC0(); - sub_81161E4(data); + LinkRfu_Shutdown(); + Leader_DestroyResources(data); data->state++; break; case 24: @@ -920,7 +1027,7 @@ static void sub_8115A68(u8 taskId) gSpecialVar_Result = 8; break; case 26: - if (sub_80FBA00()) + if (RfuIsErrorStatus1or2()) { data->state = 29; } @@ -928,9 +1035,9 @@ static void sub_8115A68(u8 taskId) { if (gReceivedRemoteLinkPlayers != 0) { - sub_80FAFE0(1); - sub_8117990(); - sub_81161E4(data); + UpdateGameData_GroupLockedIn(TRUE); + CreateTask_RunScriptAndFadeToActivity(); + Leader_DestroyResources(data); DestroyTask(taskId); } } @@ -938,196 +1045,196 @@ static void sub_8115A68(u8 taskId) } } -static void sub_81161E4(struct UnkStruct_Leader * data) +static void Leader_DestroyResources(struct UnkStruct_Leader * data) { - ClearWindowTilemap(data->field_11); - ClearStdWindowAndFrame(data->field_11, FALSE); + ClearWindowTilemap(data->nPlayerModeWindowId); + ClearStdWindowAndFrame(data->nPlayerModeWindowId, FALSE); DestroyListMenuTask(data->listTaskId, 0, 0); - ClearWindowTilemap(data->field_10); + ClearWindowTilemap(data->bButtonCancelWindowId); ClearStdWindowAndFrame(data->listWindowId, FALSE); CopyBgTilemapBufferToVram(0); - RemoveWindow(data->field_11); + RemoveWindow(data->nPlayerModeWindowId); RemoveWindow(data->listWindowId); - RemoveWindow(data->field_10); - DestroyTask(data->field_17); + RemoveWindow(data->bButtonCancelWindowId); + DestroyTask(data->listenTaskId); Free(data->field_8); Free(data->field_0); Free(data->field_4); } -static void sub_8116244(u8 *dst, u8 caseId) +static void Leader_GetAcceptNewMemberPrompt(u8 *dst, u8 activity) { - switch (caseId) + switch (activity) { - case 1: - case 2: - case 4: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_TRADE: StringExpandPlaceholders(dst, gUnknown_84574A0); break; - case 21: - case 22: + case ACTIVITY_WCARD2: + case ACTIVITY_WNEWS2: StringExpandPlaceholders(dst, gUnknown_84574C4); break; - case 3: - case 9: - case 10: - case 11: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: StringExpandPlaceholders(dst, gUnknown_84574EC); break; } } -static void sub_81162E0(u8 *dst, u8 caseId) +static void GetYouDeclinedTheOfferMessage(u8 *dst, u8 activity) { - switch (caseId) + switch (activity) { - case 65: - case 68: + case ACTIVITY_BATTLE | IN_UNION_ROOM: + case ACTIVITY_TRADE | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8457E28); break; - case 69: - case 72: + case ACTIVITY_CHAT | IN_UNION_ROOM: + case ACTIVITY_CARD | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8457E44); break; } } -static void sub_811631C(u8 *dst, u8 caseId) +static void GetYouAskedToJoinGroupPleaseWaitMessage(u8 *dst, u8 activity) { - switch (caseId) + switch (activity) { - case 1: - case 2: - case 4: - case 21: - case 22: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_TRADE: + case ACTIVITY_WCARD2: + case ACTIVITY_WNEWS2: StringExpandPlaceholders(dst, gUnknown_8459238); break; - case 3: - case 9: - case 10: - case 11: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: StringExpandPlaceholders(dst, gUnknown_8459250); break; } } -static void sub_81163B0(u8 *dst, u8 caseId) +static void GetGroupLeaderSentAnOKMessage(u8 *dst, u8 caseId) { switch (caseId) { - case 1: - case 2: - case 4: - case 21: - case 22: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_TRADE: + case ACTIVITY_WCARD2: + case ACTIVITY_WNEWS2: StringExpandPlaceholders(dst, gUnknown_84576AC); break; - case 3: - case 9: - case 10: - case 11: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: StringExpandPlaceholders(dst, gUnknown_84576C4); break; } } -static bool8 sub_8116444(struct UnkStruct_Leader * data, u32 arg1, u32 arg2) +static bool8 Leader_SetStateIfMemberListChanged(struct UnkStruct_Leader * data, u32 state1, u32 state2) { - switch (sub_8116524(data->field_0)) + switch (LeaderUpdateGroupMembership(data->field_0)) { - case 1: + case UNION_ROOM_SPAWN_IN: PlaySE(SE_PC_LOGIN); RedrawListMenu(data->listTaskId); - IntlConvPartnerUname7(gStringVar2, data->field_0->arr[data->field_13]); - sub_8116244(gStringVar4, gUnknown_203B058); - data->state = arg1; + IntlConvPartnerUname7(gStringVar2, data->field_0->arr[data->playerCount]); + Leader_GetAcceptNewMemberPrompt(gStringVar4, sPlayerCurrActivity); + data->state = state1; break; - case 2: - sub_80FB9E4(0, 0); + case UNION_ROOM_SPAWN_OUT: + RfuSetErrorStatus(0, 0); RedrawListMenu(data->listTaskId); - data->state = arg2; + data->state = state2; return TRUE; } return FALSE; } -static void sub_81164C8(u8 windowId, s32 itemId, u8 y) +static void ItemPrintFunc_PossibleGroupMembers(u8 windowId, s32 itemId, u8 y) { struct UnkStruct_Leader * data = sUnionRoomMain.leader; u8 var = 0; - switch (data->field_0->arr[itemId].field_1A_0) + switch (data->field_0->arr[itemId].groupScheduledAnim) { - case 1: + case UNION_ROOM_SPAWN_IN: if (data->field_0->arr[itemId].field_1B != 0) - var = 2; + var = UR_COLOR_GRN_WHT_LTG; break; - case 2: - var = 1; + case UNION_ROOM_SPAWN_OUT: + var = UR_COLOR_RED_WHT_LTR; break; } - sub_811A910(windowId, 0, y, &data->field_0->arr[itemId], var, itemId); + PrintGroupMemberCandidateOnWindowWithColor(windowId, 0, y, &data->field_0->arr[itemId], var, itemId); } -static u8 sub_8116524(struct UnkStruct_Main0 * arg0) +static u8 LeaderUpdateGroupMembership(struct UnkStruct_Main0 * arg0) { struct UnkStruct_Leader * data = sUnionRoomMain.leader; - u8 ret = 0; + u8 ret = UNION_ROOM_SPAWN_NONE; u8 i; s32 id; - for (i = 1; i < 5; i++) + for (i = 1; i < UROOM_MAX_PARTY_SIZE; i++) { - u16 var = data->field_0->arr[i].field_1A_0; - if (var == 1) + u16 var = data->field_0->arr[i].groupScheduledAnim; + if (var == UNION_ROOM_SPAWN_IN) { - id = sub_811A748(&data->field_0->arr[i], data->field_4->arr); + id = Findx20Inx1CArray(&data->field_0->arr[i], data->field_4->arr); if (id != 0xFF) { - data->field_0->arr[i].unk = data->field_4->arr[id].unk0; - data->field_0->arr[i].field_18 = var; + data->field_0->arr[i].gname_uname = data->field_4->arr[id].gname_uname; + data->field_0->arr[i].field_18 = 1; } else { - data->field_0->arr[i].field_1A_0 = 2; - ret = 2; + data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_OUT; + ret = UNION_ROOM_SPAWN_OUT; } } } - for (id = 0; id < 4; id++) - sub_811A798(data->field_0->arr, &data->field_4->arr[id], 5); + for (id = 0; id < RFU_CHILD_MAX; id++) + Appendx1Ctox20(data->field_0->arr, &data->field_4->arr[id], UROOM_MAX_PARTY_SIZE); - if (ret != 2) + if (ret != UNION_ROOM_SPAWN_OUT) { - for (id = 0; id < 5; id++) + for (id = 0; id < UROOM_MAX_PARTY_SIZE; id++) { if (data->field_0->arr[id].field_1B != 0) - ret = 1; + ret = UNION_ROOM_SPAWN_IN; } } return ret; } -static u8 sub_81165E8(struct UnkStruct_Main0 * arg0) +static u8 UnionRoomLeaderField0CompactionAndCount(struct UnkStruct_Main0 * arg0) { struct UnkStruct_Leader * data = sUnionRoomMain.leader; u8 copiedCount; s32 i; u8 ret; - for (i = 0; i < 5; i++) + for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++) data->field_8->arr[i] = data->field_0->arr[i]; copiedCount = 0; - for (i = 0; i < 5; i++) + for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++) { - if (data->field_8->arr[i].field_1A_0 == 1) + if (data->field_8->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { data->field_0->arr[copiedCount] = data->field_8->arr[i]; copiedCount++; @@ -1135,18 +1242,18 @@ static u8 sub_81165E8(struct UnkStruct_Main0 * arg0) } ret = copiedCount; - for (; copiedCount < 5; copiedCount++) + for (; copiedCount < UROOM_MAX_PARTY_SIZE; copiedCount++) { - data->field_0->arr[copiedCount].unk = gUnknown_8457034; + data->field_0->arr[copiedCount].gname_uname = sUnionGnameUnamePair_Dummy; data->field_0->arr[copiedCount].field_18 = 0; - data->field_0->arr[copiedCount].field_1A_0 = 0; - data->field_0->arr[copiedCount].field_1A_1 = 0; + data->field_0->arr[copiedCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; + data->field_0->arr[copiedCount].field_1A_1 = FALSE; data->field_0->arr[copiedCount].field_1B = 0; } - for (i = 0; i < 5; i++) + for (i = 0; i < UROOM_MAX_PARTY_SIZE; i++) { - if (data->field_0->arr[i].field_1A_0 != 1) + if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_IN) continue; if (data->field_0->arr[i].field_1B != 0x40) continue; @@ -1163,7 +1270,7 @@ void TryJoinLinkGroup(void) u8 taskId; struct UnkStruct_Group * dataPtr; - taskId = CreateTask(sub_8116738, 0); + taskId = CreateTask(Task_TryJoinLinkGroup, 0); sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data); sGroup = dataPtr; @@ -1172,7 +1279,7 @@ void TryJoinLinkGroup(void) gSpecialVar_Result = 0; } -static void sub_8116738(u8 taskId) +static void Task_TryJoinLinkGroup(u8 taskId) { s32 id; struct UnkStruct_Group * data = sUnionRoomMain.group; @@ -1180,11 +1287,11 @@ static void sub_8116738(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(gUnknown_84570C8[gSpecialVar_0x8004], 0, 0); - gUnknown_203B058 = gUnknown_84570C8[gSpecialVar_0x8004]; - sub_800B1F4(); + SetHostRFUtgtGname(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, 0); + sPlayerCurrActivity = sLinkGroupToURoomActivity[gSpecialVar_0x8004]; + SetWirelessCommType1(); OpenLink(); - sub_80FBBD8(); + InitializeRfuLinkManager_JoinGroup(); data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20)); data->state = 1; @@ -1194,34 +1301,34 @@ static void sub_8116738(u8 taskId) data->state = 2; break; case 2: - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 16); - data->field_11 = sub_811A054(data->field_4, gSpecialVar_0x8004); - data->field_C = AddWindow(&gUnknown_8456CD0); - data->listWindowId = AddWindow(&gUnknown_8456D4C); - data->field_D = AddWindow(&gUnknown_8456D54); - - FillWindowPixelBuffer(data->field_C, PIXEL_FILL(2)); - sub_811A444(data->field_C, 0, gUnknown_8458FC8, 8, 2, 4); - PutWindowTilemap(data->field_C); - CopyWindowToVram(data->field_C, 2); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, 16); + data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, gSpecialVar_0x8004); + data->bButtonCancelWindowId = AddWindow(&sWindowTemplate_BButtonCancel); + data->listWindowId = AddWindow(&sWindowTemplate_MysteryGiftList); + data->playerNameAndIdWindowId = AddWindow(&sWindowTemplate_MysteryGiftPlayerNameAndId); + + FillWindowPixelBuffer(data->bButtonCancelWindowId, PIXEL_FILL(2)); + UR_AddTextPrinterParameterized(data->bButtonCancelWindowId, 0, gUnknown_8458FC8, 8, 2, UR_COLOR_WHT_DKE_LTE); + PutWindowTilemap(data->bButtonCancelWindowId); + CopyWindowToVram(data->bButtonCancelWindowId, 2); DrawStdWindowFrame(data->listWindowId, FALSE); - gMultiuseListMenuTemplate = gUnknown_8456DDC; + gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups; gMultiuseListMenuTemplate.windowId = data->listWindowId; data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); - DrawStdWindowFrame(data->field_D, FALSE); - PutWindowTilemap(data->field_D); - sub_8115924(data->field_D); - CopyWindowToVram(data->field_D, 2); + DrawStdWindowFrame(data->playerNameAndIdWindowId, FALSE); + PutWindowTilemap(data->playerNameAndIdWindowId); + PrintPlayerNameAndIdOnWindow(data->playerNameAndIdWindowId); + CopyWindowToVram(data->playerNameAndIdWindowId, 2); CopyBgTilemapBufferToVram(0); - data->field_F = 0; + data->leaderId = 0; data->state = 3; break; case 3: - id = sub_8116FE4(); + id = GetNewLeaderCandidate(); switch (id) { case 1: @@ -1234,19 +1341,20 @@ static void sub_8116738(u8 taskId) { // this unused variable along with the assignment is needed to match u32 unusedVar; - unusedVar = data->field_0->arr[id].unk.gname.unk_0a_0; + unusedVar = data->field_0->arr[id].gname_uname.gname.activity; - if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.gname.unk_0a_7) + if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started) { - u32 var = sub_8116D10(data, id); + u32 var = IsTryingToTradeWithHoennTooSoon(data, id); if (var == 0) { - sub_8116D60(data, id); + AskToJoinRfuGroup(data, id); data->state = 5; PlaySE(SE_PN_ON); } else { + // Postgame flags not both set StringCopy(gStringVar4, gUnknown_8457608[var - 1]); data->state = 18; PlaySE(SE_PN_ON); @@ -1268,30 +1376,38 @@ static void sub_8116738(u8 taskId) } break; case 5: - sub_811631C(gStringVar4, gUnknown_203B058); + GetYouAskedToJoinGroupPleaseWaitMessage(gStringVar4, sPlayerCurrActivity); if (PrintOnTextbox(&data->textState, gStringVar4)) { - IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_F]); + IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->leaderId]); data->state = 6; } break; case 6: if (gReceivedRemoteLinkPlayers != 0) { - gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0; - sub_80FB9E4(0, 0); - switch (gUnknown_203B058) + sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity; + RfuSetErrorStatus(0, 0); + switch (sPlayerCurrActivity) { - case 1 ... 5: - case 9 ... 11: - case 13 ... 14: - case 21 ... 22: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_TRADE: + case ACTIVITY_CHAT: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: + case ACTIVITY_SPINTRADE: + case ACTIVITY_ITEMTRADE: + case ACTIVITY_WCARD2: + case ACTIVITY_WNEWS2: data->state = 20; break; } } - switch (sub_80FB9F4()) + switch (RfuGetErrorStatus()) { case 1: data->state = 12; @@ -1302,31 +1418,32 @@ static void sub_8116738(u8 taskId) data->state = 14; break; case 5: - sub_81163B0(gStringVar4, gUnknown_203B058); + GetGroupLeaderSentAnOKMessage(gStringVar4, sPlayerCurrActivity); if (PrintOnTextbox(&data->textState, gStringVar4)) { - sub_80FB9E4(7, 0); - StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]); + RfuSetErrorStatus(7, 0); + StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]); StringExpandPlaceholders(gStringVar4, gUnknown_8457700); } break; case 7: - if (data->field_15 > 0xF0) + // Wait 4 seconds + if (data->delayBeforePrint > 240) { if (PrintOnTextbox(&data->textState, gStringVar4)) { - sub_80FB9E4(12, 0); - data->field_15 = 0; + RfuSetErrorStatus(12, 0); + data->delayBeforePrint = 0; } } else { - data->field_15++; + data->delayBeforePrint++; } break; } - if (!sub_80FB9F4() && JOY_NEW(B_BUTTON)) + if (!RfuGetErrorStatus() && JOY_NEW(B_BUTTON)) data->state = 7; break; case 7: @@ -1334,10 +1451,10 @@ static void sub_8116738(u8 taskId) data->state = 8; break; case 8: - switch (sub_811A14C(&data->textState, sub_80FB9F4())) + switch (UnionRoomHandleYesNo(&data->textState, RfuGetErrorStatus())) { case 0: - sub_80FA6BC(); + LinkRfuNIsend8(); data->state = 9; RedrawListMenu(data->listTaskId); break; @@ -1353,7 +1470,7 @@ static void sub_8116738(u8 taskId) } break; case 9: - if (sub_80FB9F4()) + if (RfuGetErrorStatus()) data->state = 6; break; case 10: @@ -1361,23 +1478,23 @@ static void sub_8116738(u8 taskId) case 14: case 18: case 20: - ClearWindowTilemap(data->field_D); - ClearStdWindowAndFrame(data->field_D, FALSE); + ClearWindowTilemap(data->playerNameAndIdWindowId); + ClearStdWindowAndFrame(data->playerNameAndIdWindowId, FALSE); DestroyListMenuTask(data->listTaskId, 0, 0); - ClearWindowTilemap(data->field_C); + ClearWindowTilemap(data->bButtonCancelWindowId); ClearStdWindowAndFrame(data->listWindowId, FALSE); CopyBgTilemapBufferToVram(0); - RemoveWindow(data->field_D); + RemoveWindow(data->playerNameAndIdWindowId); RemoveWindow(data->listWindowId); - RemoveWindow(data->field_C); - DestroyTask(data->field_11); + RemoveWindow(data->bButtonCancelWindowId); + DestroyTask(data->listenTaskId); Free(data->field_0); Free(data->field_4); data->state++; break; case 13: DestroyWirelessStatusIndicatorSprite(); - if (PrintOnTextbox(&data->textState, gUnknown_8457754[sub_80FB9F4()])) + if (PrintOnTextbox(&data->textState, gUnknown_8457754[RfuGetErrorStatus()])) { gSpecialVar_Result = 6; data->state = 23; @@ -1390,7 +1507,7 @@ static void sub_8116738(u8 taskId) break; case 15: DestroyWirelessStatusIndicatorSprite(); - if (PrintOnTextbox(&data->textState, gUnknown_8457754[sub_80FB9F4()])) + if (PrintOnTextbox(&data->textState, gUnknown_8457754[RfuGetErrorStatus()])) { gSpecialVar_Result = 8; data->state = 23; @@ -1405,25 +1522,25 @@ static void sub_8116738(u8 taskId) break; case 23: DestroyTask(taskId); - sub_811A41C(); - sub_80F8DC0(); + JoinGroup_BlankBg0AndEnableScriptContexts(); + LinkRfu_Shutdown(); break; case 21: - sub_8117990(); + CreateTask_RunScriptAndFadeToActivity(); DestroyTask(taskId); break; } } -static u32 sub_8116D10(struct UnkStruct_Group * arg0, s32 id) +static u32 IsTryingToTradeWithHoennTooSoon(struct UnkStruct_Group * arg0, s32 id) { struct UnkStruct_x20 * structPtr = &arg0->field_0->arr[id]; - if (gUnknown_203B058 == 4 && structPtr->unk.gname.unk_00.unk_01_2 != VERSION_FIRE_RED && structPtr->unk.gname.unk_00.unk_01_2 != VERSION_LEAF_GREEN) + if (sPlayerCurrActivity == ACTIVITY_TRADE && structPtr->gname_uname.gname.unk_00.version != VERSION_FIRE_RED && structPtr->gname_uname.gname.unk_00.version != VERSION_LEAF_GREEN) { if (!(gSaveBlock2Ptr->specialSaveWarpFlags & CHAMPION_SAVEWARP)) return 1; - else if (structPtr->unk.gname.unk_00.isChampion) + else if (structPtr->gname_uname.gname.unk_00.isChampion) return 0; } else @@ -1434,23 +1551,23 @@ static u32 sub_8116D10(struct UnkStruct_Group * arg0, s32 id) return 2; } -static void sub_8116D60(struct UnkStruct_Group * data, s32 id) +static void AskToJoinRfuGroup(struct UnkStruct_Group * data, s32 id) { - data->field_F = id; + data->leaderId = id; LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); RedrawListMenu(data->listTaskId); - IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_F]); - sub_80FB008(gUnknown_84570C8[gSpecialVar_0x8004], 0, 1); - sub_80FBF54(data->field_0->arr[data->field_F].unk.playerName, ReadAsU16(data->field_0->arr[data->field_F].unk.gname.unk_00.playerTrainerId)); + IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->leaderId]); + UpdateGameDataWithActivitySpriteGendersFlag(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, TRUE); + CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId)); } -u8 sub_8116DE0(void) +u8 CreateTask_ListenToWireless(void) { u8 taskId; struct UnkStruct_Group * dataPtr; - taskId = CreateTask(sub_8116E1C, 0); + taskId = CreateTask(Task_ListenToWireless, 0); sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data); dataPtr->state = 0; @@ -1461,7 +1578,7 @@ u8 sub_8116DE0(void) return taskId; } -static void sub_8116E1C(u8 taskId) +static void Task_ListenToWireless(u8 taskId) { struct UnkStruct_Group * data = sUnionRoomMain.group; @@ -1469,53 +1586,53 @@ static void sub_8116E1C(u8 taskId) { case 0: SetHostRFUtgtGname(0, 0, 0); - sub_800B1F4(); + SetWirelessCommType1(); OpenLink(); - sub_80FBBD8(); + InitializeRfuLinkManager_JoinGroup(); sub_80FB128(TRUE); data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20)); data->state = 2; break; case 2: - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 16); - data->field_11 = sub_811A054(data->field_4, 0xFF); - data->field_F = 0; + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, 16); + data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF); + data->leaderId = 0; data->state = 3; break; case 3: - if (sub_8116FE4() == 1) + if (GetNewLeaderCandidate() == 1) PlaySE(SE_PC_LOGIN); if (gTasks[taskId].data[15] == 0xFF) data->state = 10; break; case 10: - DestroyTask(data->field_11); + DestroyTask(data->listenTaskId); Free(data->field_0); Free(data->field_4); - sub_80F8DC0(); + LinkRfu_Shutdown(); data->state++; break; case 11: - sub_80F8DC0(); + LinkRfu_Shutdown(); DestroyTask(taskId); break; } } -static bool32 sub_8116F28(u32 arg0, u32 id) +static bool32 IsPartnerActivityAcceptable(u32 activity, u32 group) { - if (id == 0xFF) + if (group == 0xFF) return TRUE; - if (id <= NELEMS(gUnknown_8457094)) // UB: <= may access data outside the array + if (group <= NELEMS(sAcceptedActivityIds)) // UB: <= may access data outside the array { - const u8 *bytes = gUnknown_8457094[id]; + const u8 *bytes = sAcceptedActivityIds[group]; while ((*(bytes) != 0xFF)) { - if ((*bytes) == arg0) + if ((*bytes) == activity) return TRUE; bytes++; } @@ -1524,30 +1641,30 @@ static bool32 sub_8116F28(u32 arg0, u32 id) return FALSE; } -static u8 sub_8116F5C(struct UnkStruct_Group * data, u32 id) +static u8 URoomGroupListGetTextColor(struct UnkStruct_Group * data, u32 id) { - if (data->field_0->arr[id].field_1A_0 == 1) + if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - if (data->field_0->arr[id].unk.gname.unk_0a_7) - return 3; - else if (data->field_0->arr[id].field_1A_1 != 0) - return 1; + if (data->field_0->arr[id].gname_uname.gname.started) + return UR_COLOR_WHT_WHT_LTE; + else if (data->field_0->arr[id].field_1A_1) + return UR_COLOR_RED_WHT_LTR; else if (data->field_0->arr[id].field_1B != 0) - return 2; + return UR_COLOR_GRN_WHT_LTG; } - return 0; + return UR_COLOR_DKE_WHT_LTE; } -static void sub_8116F94(u8 windowId, s32 itemId, u8 y) +static void ListMenuItemPrintFunc_UnionRoomGroups(u8 windowId, s32 itemId, u8 y) { struct UnkStruct_Group * data = sUnionRoomMain.group; - u8 var = sub_8116F5C(data, itemId); + u8 color_idx = URoomGroupListGetTextColor(data, itemId); - sub_811A81C(windowId, 8, y, &data->field_0->arr[itemId], var, itemId); + PrintUnionRoomGroupOnWindow(windowId, 8, y, &data->field_0->arr[itemId], color_idx, itemId); } -static u8 sub_8116FE4(void) +static u8 GetNewLeaderCandidate(void) { struct UnkStruct_Group * data = sUnionRoomMain.group; u8 ret = 0; @@ -1556,17 +1673,17 @@ static u8 sub_8116FE4(void) for (i = 0; i < 16; i++) { - if (data->field_0->arr[i].field_1A_0 != 0) + if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_NONE) { - id = sub_811A748(&data->field_0->arr[i], data->field_4->arr); + id = Findx20Inx1CArray(&data->field_0->arr[i], data->field_4->arr); if (id != 0xFF) { - if (data->field_0->arr[i].field_1A_0 == 1) + if (data->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - if (sub_811A6DC(&data->field_0->arr[i].unk, &data->field_4->arr[id].unk0)) + if (AreUnionRoomPlayerGnamesDifferent(&data->field_0->arr[i].gname_uname, &data->field_4->arr[id].gname_uname)) { - data->field_0->arr[i].unk = data->field_4->arr[id].unk0; - data->field_0->arr[i].field_1B = 0x40; + data->field_0->arr[i].gname_uname = data->field_4->arr[id].gname_uname; + data->field_0->arr[i].field_1B = 64; ret = 1; } else @@ -1581,8 +1698,8 @@ static u8 sub_8116FE4(void) } else { - data->field_0->arr[i].field_1A_0 = 1; - data->field_0->arr[i].field_1B = 0x40; + data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_IN; + data->field_0->arr[i].field_1B = 64; ret = 1; } @@ -1590,12 +1707,12 @@ static u8 sub_8116FE4(void) } else { - if (data->field_0->arr[i].field_1A_0 != 2) + if (data->field_0->arr[i].groupScheduledAnim != UNION_ROOM_SPAWN_OUT) { data->field_0->arr[i].field_18++; if (data->field_0->arr[i].field_18 >= 300) { - data->field_0->arr[i].field_1A_0 = 2; + data->field_0->arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_OUT; ret = 2; } } @@ -1603,29 +1720,29 @@ static u8 sub_8116FE4(void) } } - for (id = 0; id < 4; id++) + for (id = 0; id < RFU_CHILD_MAX; id++) { - if (sub_811A798(data->field_0->arr, &data->field_4->arr[id], 16) != 0xFF) + if (Appendx1Ctox20(data->field_0->arr, &data->field_4->arr[id], 16) != 0xFF) ret = 1; } return ret; } -static void sub_8117100(u8 taskId) +static void Task_CallCB2ReturnFromLinkTrade(u8 taskId) { CB2_ReturnFromLinkTrade(); DestroyTask(taskId); } -u8 sub_8117118(void) +u8 UnionRoom_CreateTask_CallBC2ReturnFromLinkTrade(void) { - u8 taskId = CreateTask(sub_8117100, 0); + u8 taskId = CreateTask(Task_CallCB2ReturnFromLinkTrade, 0); return taskId; } -static void sub_8117130(u8 taskId) +static void Task_StartUnionRoomTrade(u8 taskId) { u32 monId = GetPartyPositionOfRegisteredMon(&sUnionRoomTrade, GetMultiplayerId()); @@ -1665,7 +1782,7 @@ static void sub_8117130(u8 taskId) } } -static void sub_8117280(u8 taskId) +static void Task_ExchangeCards(u8 taskId) { switch (gTasks[taskId].data[0]) { @@ -1689,11 +1806,11 @@ static void sub_8117280(u8 taskId) if (GetLinkPlayerCount() == 2) { recvBuff = gBlockRecvBuffer[GetMultiplayerId() ^ 1]; - sub_81446D0(recvBuff[48]); + MEventHandleReceivedWonderCard(recvBuff[sizeof(struct TrainerCard) / 2]); } else { - sub_81446C4(); + ResetReceivedWonderCardFlag(); } ResetBlockReceivedFlags(); @@ -1703,16 +1820,16 @@ static void sub_8117280(u8 taskId) } } -static void sub_8117354(void) +static void CB2_ShowCard(void) { switch (gMain.state) { case 0: - CreateTask(sub_8117280, 5); + CreateTask(Task_ExchangeCards, 5); gMain.state++; break; case 1: - if (!FuncIsActiveTask(sub_8117280)) + if (!FuncIsActiveTask(Task_ExchangeCards)) ShowTrainerCardInLink(GetMultiplayerId() ^ 1, CB2_ReturnToField); break; } @@ -1723,7 +1840,7 @@ static void sub_8117354(void) BuildOamBuffer(); } -void sub_81173C0(u16 battleFlags) +void StartUnionRoomBattle(u16 battleFlags) { HealPlayerParty(); SavePlayerParty(); @@ -1736,7 +1853,7 @@ void sub_81173C0(u16 battleFlags) PlayBattleBGM(); } -static void sub_8117440(u16 linkService, u16 x, u16 y) +static void SetCableClubStateAndWarpCurrentMap(u16 linkService, u16 x, u16 y) { VarSet(VAR_CABLE_CLUB_STATE, linkService); SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, x, y); @@ -1744,7 +1861,7 @@ static void sub_8117440(u16 linkService, u16 x, u16 y) WarpIntoMap(); } -static void sub_81174B4(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService) +static void SetCableClubStateAndWarpToNewMap(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService) { gSpecialVar_0x8004 = linkService; VarSet(VAR_CABLE_CLUB_STATE, linkService); @@ -1755,17 +1872,17 @@ static void sub_81174B4(s8 mapGroup, s8 mapNum, s32 x, s32 y, u16 linkService) WarpIntoMap(); } -static void sub_8117534(void) +static void CB2_TransitionToCableClub(void) { switch (gMain.state) { case 0: - CreateTask(sub_8117280, 5); + CreateTask(Task_ExchangeCards, 5); gMain.state++; break; case 1: - if (!FuncIsActiveTask(sub_8117280)) - SetMainCallback2(sub_8056788); + if (!FuncIsActiveTask(Task_ExchangeCards)) + SetMainCallback2(CB2_ReturnToFieldCableClub); break; } @@ -1775,101 +1892,106 @@ static void sub_8117534(void) BuildOamBuffer(); } -static void sub_8117594(void *arg0, bool32 arg1) +static void CreateTrainerCardInBuffer(void *dest, bool32 setWonderCard) { - TrainerCard_GenerateCardForLinkPlayer((struct TrainerCard * )arg0); - if (arg1) - *((u16 *)(arg0 + sizeof(struct TrainerCard))) = GetWonderCardFlagId(); + TrainerCard_GenerateCardForLinkPlayer((struct TrainerCard * )dest); + if (setWonderCard) + *((u16 *)(dest + sizeof(struct TrainerCard))) = GetWonderCardFlagId(); else - *((u16 *)(arg0 + sizeof(struct TrainerCard))) = 0; + *((u16 *)(dest + sizeof(struct TrainerCard))) = 0; } -static void sub_81175BC(u8 taskId) +static void Task_StartActivity(u8 taskId) { - sub_81446C4(); - switch (gUnknown_203B058) + ResetReceivedWonderCardFlag(); + switch (sPlayerCurrActivity) { - case 1 ... 4: - case 9 ... 11: - case 13: - case 14: + case ACTIVITY_BATTLE: + case ACTIVITY_DBLBATTLE: + case ACTIVITY_MLTBATTLE: + case ACTIVITY_TRADE: + case ACTIVITY_PJUMP: + case ACTIVITY_BCRUSH: + case ACTIVITY_BPICK: + case ACTIVITY_SPINTRADE: + case ACTIVITY_ITEMTRADE: RecordMixTrainerNames(); break; } - switch (gUnknown_203B058) + switch (sPlayerCurrActivity) { - case 65: - case 81: + case ACTIVITY_BATTLE | IN_UNION_ROOM: + case ACTIVITY_ACCEPT | IN_UNION_ROOM: CleanupOverworldWindowsAndTilemaps(); - gMain.savedCallback = sub_811C1C8; + gMain.savedCallback = CB2_UnionRoomBattle; InitChooseHalfPartyForBattle(2); break; - case 1: + case ACTIVITY_BATTLE: CleanupOverworldWindowsAndTilemaps(); - sub_8117594(gBlockSendBuffer, TRUE); + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); HealPlayerParty(); SavePlayerParty(); LoadPlayerBag(); - sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_SINGLE_BATTLE); - SetMainCallback2(sub_8117534); + SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_SINGLE_BATTLE); + SetMainCallback2(CB2_TransitionToCableClub); break; - case 2: + case ACTIVITY_DBLBATTLE: CleanupOverworldWindowsAndTilemaps(); HealPlayerParty(); SavePlayerParty(); LoadPlayerBag(); - sub_8117594(gBlockSendBuffer, TRUE); - sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_DOUBLE_BATTLE); - SetMainCallback2(sub_8117534); + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); + SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_2P), MAP_NUM(BATTLE_COLOSSEUM_2P), 6, 8, USING_DOUBLE_BATTLE); + SetMainCallback2(CB2_TransitionToCableClub); break; - case 3: + case ACTIVITY_MLTBATTLE: CleanupOverworldWindowsAndTilemaps(); HealPlayerParty(); SavePlayerParty(); LoadPlayerBag(); - sub_8117594(gBlockSendBuffer, TRUE); - sub_81174B4(MAP_GROUP(BATTLE_COLOSSEUM_4P), MAP_NUM(BATTLE_COLOSSEUM_4P), 5, 8, USING_MULTI_BATTLE); - SetMainCallback2(sub_8117534); + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); + SetCableClubStateAndWarpToNewMap(MAP_GROUP(BATTLE_COLOSSEUM_4P), MAP_NUM(BATTLE_COLOSSEUM_4P), 5, 8, USING_MULTI_BATTLE); + SetMainCallback2(CB2_TransitionToCableClub); break; - case 4: - sub_8117594(gBlockSendBuffer, TRUE); + case ACTIVITY_TRADE: + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); CleanupOverworldWindowsAndTilemaps(); - sub_81174B4(MAP_GROUP(TRADE_CENTER), MAP_NUM(TRADE_CENTER), 5, 8, USING_TRADE_CENTER); - SetMainCallback2(sub_8117534); + SetCableClubStateAndWarpToNewMap(MAP_GROUP(TRADE_CENTER), MAP_NUM(TRADE_CENTER), 5, 8, USING_TRADE_CENTER); + SetMainCallback2(CB2_TransitionToCableClub); break; - case 68: - CreateTask(sub_8117130, 0); + case ACTIVITY_TRADE | IN_UNION_ROOM: + CreateTask(Task_StartUnionRoomTrade, 0); break; - case 5: - case 69: + case ACTIVITY_CHAT: + case ACTIVITY_CHAT | IN_UNION_ROOM: if (GetMultiplayerId() == 0) { - sub_80F8CFC(); + LinkRfu_CreateConnectionAsParent(); } else { - sub_80F8D14(); - SetHostRFUtgtGname(69, 0, 1); + LinkRfu_StopManagerBeforeEnteringChat(); + SetHostRFUtgtGname(ACTIVITY_CHAT | IN_UNION_ROOM, 0, 1); } EnterUnionRoomChat(); break; - case 8: - case 72: - sub_8117594(gBlockSendBuffer, FALSE); - SetMainCallback2(sub_8117354); + case ACTIVITY_CARD: + case ACTIVITY_CARD | IN_UNION_ROOM: + CreateTrainerCardInBuffer(gBlockSendBuffer, FALSE); + SetMainCallback2(CB2_ShowCard); break; - case 9: - sub_8117440(USING_MINIGAME, 5, 1); - sub_8147AA8(GetCursorSelectionMonId(), CB2_LoadMap); + case ACTIVITY_PJUMP: + SetCableClubStateAndWarpCurrentMap(USING_MINIGAME, 5, 1); + StartPokemonJump(GetCursorSelectionMonId(), CB2_LoadMap); break; - case 10: - sub_8117440(USING_BERRY_CRUSH, 9, 1); - sub_814B754(CB2_LoadMap); + case ACTIVITY_BCRUSH: + SetCableClubStateAndWarpCurrentMap(USING_BERRY_CRUSH, 9, 1); + StartBerryCrush(CB2_LoadMap); break; - case 11: - sub_8117440(USING_MINIGAME, 5, 1); - sub_81507FC(GetCursorSelectionMonId(), CB2_LoadMap); + case ACTIVITY_BPICK: + SetCableClubStateAndWarpCurrentMap(USING_MINIGAME, 5, 1); + StartDodrioBerryPicking(GetCursorSelectionMonId(), CB2_LoadMap); break; } @@ -1878,7 +2000,7 @@ static void sub_81175BC(u8 taskId) ScriptContext2_Disable(); } -static void sub_8117900(u8 taskId) +static void Task_RunScriptAndFadeToActivity(u8 taskId) { s16 *data = gTasks[taskId].data; u16 *sendBuff = (u16*)(gBlockSendBuffer); @@ -1900,7 +2022,7 @@ static void sub_8117900(u8 taskId) case 2: if (!gPaletteFade.active) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); data[0]++; } break; @@ -1908,38 +2030,38 @@ static void sub_8117900(u8 taskId) if (IsLinkTaskFinished()) { DestroyTask(taskId); - sub_81179A4(); + CreateTask_StartActivity(); } break; } } -static void sub_8117990(void) +static void CreateTask_RunScriptAndFadeToActivity(void) { - CreateTask(sub_8117900, 0); + CreateTask(Task_RunScriptAndFadeToActivity, 0); } -static void sub_81179A4(void) +static void CreateTask_StartActivity(void) { - u8 taskId = CreateTask(sub_81175BC, 0); + u8 taskId = CreateTask(Task_StartActivity, 0); gTasks[taskId].data[0] = 0; } -void MEvent_CreateTask_Leader(u32 arg0) +void MEvent_CreateTask_Leader(u32 activity) { u8 taskId; struct UnkStruct_Leader * dataPtr; - taskId = CreateTask(sub_8117A0C, 0); + taskId = CreateTask(Task_MEvent_Leader, 0); sUnionRoomMain.leader = dataPtr = (void*)(gTasks[taskId].data); dataPtr->state = 0; dataPtr->textState = 0; - dataPtr->field_18 = arg0; + dataPtr->activity = activity; gSpecialVar_Result = 0; } -static void sub_8117A0C(u8 taskId) +static void Task_MEvent_Leader(u8 taskId) { struct UnkStruct_Leader * data = sUnionRoomMain.leader; struct WindowTemplate winTemplate; @@ -1948,43 +2070,43 @@ static void sub_8117A0C(u8 taskId) switch (data->state) { case 0: - gUnknown_203B058 = data->field_18; - gUnknown_203B059 = 2; - SetHostRFUtgtGname(data->field_18, 0, 0); - sub_80FAF74(FALSE, FALSE); - sub_800B1F4(); + sPlayerCurrActivity = data->activity; + sPlayerActivityGroupSize = 2; + SetHostRFUtgtGname(data->activity, 0, 0); + SetGnameBufferWonderFlags(FALSE, FALSE); + SetWirelessCommType1(); OpenLink(); - sub_80FBB8C(2); + InitializeRfuLinkManager_LinkLeader(2); data->state = 1; break; case 1: data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - data->field_0 = AllocZeroed(5 * sizeof(struct UnkStruct_x20)); - data->field_8 = AllocZeroed(5 * sizeof(struct UnkStruct_x20)); - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 5); - LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].unk.gname, data->field_0->arr[0].unk.playerName); + data->field_0 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20)); + data->field_8 = AllocZeroed(UROOM_MAX_PARTY_SIZE * sizeof(struct UnkStruct_x20)); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_PARTY_SIZE); + LinkRfu3_SetGnameUnameFromStaticBuffers(&data->field_0->arr[0].gname_uname.gname, data->field_0->arr[0].gname_uname.uname); data->field_0->arr[0].field_18 = 0; - data->field_0->arr[0].field_1A_0 = 1; - data->field_0->arr[0].field_1A_1 = 0; + data->field_0->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN; + data->field_0->arr[0].field_1A_1 = FALSE; data->field_0->arr[0].field_1B = 0; - data->field_17 = sub_811A054(data->field_4, 0xFF); + data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, 0xFF); - winTemplate = gUnknown_8456CFC; + winTemplate = sWindowTemplate_List_PossibleGroupMembers; winTemplate.baseBlock = GetMysteryGiftBaseBlock(); data->listWindowId = AddWindow(&winTemplate); MG_DrawTextBorder(data->listWindowId); - gMultiuseListMenuTemplate = gUnknown_8456D34; + gMultiuseListMenuTemplate = sListMenuTemplate_PossibleGroupMembers; gMultiuseListMenuTemplate.windowId = data->listWindowId; data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); CopyBgTilemapBufferToVram(0); - data->field_13 = 1; + data->playerCount = 1; data->state = 2; break; case 2: - StringCopy(gStringVar1, gUnknown_8456C74[gUnknown_203B058]); - sub_811599C(gStringVar4, gUnknown_203B058); + StringCopy(gStringVar1, sUnionRoomActivityStringPtrs[sPlayerCurrActivity]); + StringExpandPlaceholders_AwaitingCommFromAnother(gStringVar4, sPlayerCurrActivity); data->state = 3; break; case 3: @@ -1992,7 +2114,7 @@ static void sub_8117A0C(u8 taskId) data->state = 4; break; case 4: - sub_8116444(data, 5, 6); + Leader_SetStateIfMemberListChanged(data, 5, 6); if (JOY_NEW(B_BUTTON)) { data->state = 13; @@ -2000,9 +2122,10 @@ static void sub_8117A0C(u8 taskId) } break; case 6: + // The link with your friend has been dropped... if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_84577F8)) { - data->field_13 = sub_81165E8(data->field_0); + data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); data->state = 2; } @@ -2011,44 +2134,44 @@ static void sub_8117A0C(u8 taskId) data->state = 7; break; case 7: - switch (mevent_message_print_and_prompt_yes_no(&data->textState, (u16 *)&data->field_14, FALSE, gStringVar4)) + switch (mevent_message_print_and_prompt_yes_no(&data->textState, (u16 *)&data->messageWindowId, FALSE, gStringVar4)) { case 0: LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); - data->field_0->arr[data->field_13].field_1B = 0; + data->field_0->arr[data->playerCount].field_1B = 0; RedrawListMenu(data->listTaskId); data->field_19 = 5; - sub_80FA670(5, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 8; break; case 1: case -1: data->field_19 = 6; - sub_80FA670(6, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 8; break; } break; case 8: - val = sub_80FA6FC(ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId), data->field_0->arr[data->field_13].unk.playerName); + val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); if (val == 1) { if (data->field_19 == 5) { - data->field_0->arr[data->field_13].field_1B = 0; + data->field_0->arr[data->playerCount].field_1B = 0; RedrawListMenu(data->listTaskId); - data->field_13++; - IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->field_13 - 1]); + data->playerCount++; + IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->playerCount - 1]); StringExpandPlaceholders(gStringVar4, gUnknown_8457554); data->state = 9; - sub_80F8F5C(); + LinkRfu_StopManagerAndFinalizeSlots(); } else { - sub_80FBD4C(data->field_0->arr[data->field_13].unk.playerName, ReadAsU16(data->field_0->arr[data->field_13].unk.gname.unk_00.playerTrainerId)); - data->field_0->arr[data->field_13].field_1A_0 = 0; - sub_81165E8(data->field_0); + RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId)); + data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; + UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); data->state = 2; } @@ -2057,7 +2180,7 @@ static void sub_8117A0C(u8 taskId) } else if (val == 2) { - sub_80FB9E4(0, 0); + RfuSetErrorStatus(0, 0); data->state = 2; } break; @@ -2066,17 +2189,17 @@ static void sub_8117A0C(u8 taskId) data->state = 10; break; case 10: - if (++data->field_E > 120) + if (++data->delayTimerAfterOk > 120) data->state = 11; break; case 11: - if (!sub_8116444(data, 5, 6)) + if (!Leader_SetStateIfMemberListChanged(data, 5, 6)) data->state = 12; break; case 12: - if (sub_80F8F40()) + if (LmanAcceptSlotFlagIsNotZero()) { - sub_80F8F7C(FALSE); + WaitRfuState(FALSE); data->state = 15; } else @@ -2086,17 +2209,18 @@ static void sub_8117A0C(u8 taskId) break; case 13: DestroyWirelessStatusIndicatorSprite(); - sub_80F8DC0(); + LinkRfu_Shutdown(); DestroyListMenuTask(data->listTaskId, 0, 0); CopyBgTilemapBufferToVram(0); RemoveWindow(data->listWindowId); - DestroyTask(data->field_17); + DestroyTask(data->listenTaskId); Free(data->field_8); Free(data->field_0); Free(data->field_4); data->state++; break; case 14: + // Please start over from the beginning. if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_84571B8)) { DestroyTask(taskId); @@ -2104,13 +2228,13 @@ static void sub_8117A0C(u8 taskId) } break; case 15: - if (sub_80FB9F4() == 1 || sub_80FB9F4() == 2) + if (RfuGetErrorStatus() == 1 || RfuGetErrorStatus() == 2) { data->state = 13; } else if (gReceivedRemoteLinkPlayers != 0) { - sub_80FAFE0(1); + UpdateGameData_GroupLockedIn(TRUE); data->state++; } break; @@ -2118,11 +2242,11 @@ static void sub_8117A0C(u8 taskId) DestroyListMenuTask(data->listTaskId, 0, 0); CopyBgTilemapBufferToVram(0); RemoveWindow(data->listWindowId); - DestroyTask(data->field_17); + DestroyTask(data->listenTaskId); Free(data->field_8); Free(data->field_0); Free(data->field_4); - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); data->state++; break; case 17: @@ -2132,22 +2256,22 @@ static void sub_8117A0C(u8 taskId) } } -void MEvent_CreateTask_CardOrNewsWithFriend(u32 arg0) +void MEvent_CreateTask_CardOrNewsWithFriend(u32 activity) { u8 taskId; struct UnkStruct_Group * dataPtr; - taskId = CreateTask(sub_8117F20, 0); + taskId = CreateTask(Task_CardOrNewsWithFriend, 0); sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data); sGroup = dataPtr; dataPtr->state = 0; dataPtr->textState = 0; - dataPtr->field_12 = arg0 - 21; + dataPtr->cardOrNews = activity - ACTIVITY_WCARD2; // 0: Card; 1: News gSpecialVar_Result = 0; } -static void sub_8117F20(u8 taskId) +static void Task_CardOrNewsWithFriend(u8 taskId) { s32 id; struct WindowTemplate winTemplate1, winTemplate2; @@ -2156,10 +2280,10 @@ static void sub_8117F20(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(data->field_12 + 21, 0, 0); - sub_800B1F4(); + SetHostRFUtgtGname(data->cardOrNews + ACTIVITY_WCARD2, 0, 0); + SetWirelessCommType1(); OpenLink(); - sub_80FBBD8(); + InitializeRfuLinkManager_JoinGroup(); data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20)); data->state = 1; @@ -2169,33 +2293,33 @@ static void sub_8117F20(u8 taskId) data->state = 2; break; case 2: - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 16); - data->field_11 = sub_811A054(data->field_4, data->field_12 + 7); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, 16); + data->listenTaskId = CreateTask_ListenForPartnersWithCompatibleSerialNos(data->field_4, data->cardOrNews + LINK_GROUP_WONDER_CARD); - winTemplate1 = gUnknown_8456D4C; + winTemplate1 = sWindowTemplate_MysteryGiftList; winTemplate1.baseBlock = GetMysteryGiftBaseBlock(); data->listWindowId = AddWindow(&winTemplate1); - data->field_D = AddWindow(&gUnknown_8456D54); + data->playerNameAndIdWindowId = AddWindow(&sWindowTemplate_MysteryGiftPlayerNameAndId); MG_DrawTextBorder(data->listWindowId); - gMultiuseListMenuTemplate = gUnknown_8456DDC; + gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups; gMultiuseListMenuTemplate.windowId = data->listWindowId; data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); - MG_DrawTextBorder(data->field_D); - FillWindowPixelBuffer(data->field_D, PIXEL_FILL(1)); - PutWindowTilemap(data->field_D); - sub_8115924(data->field_D); - CopyWindowToVram(data->field_D, 2); + MG_DrawTextBorder(data->playerNameAndIdWindowId); + FillWindowPixelBuffer(data->playerNameAndIdWindowId, PIXEL_FILL(1)); + PutWindowTilemap(data->playerNameAndIdWindowId); + PrintPlayerNameAndIdOnWindow(data->playerNameAndIdWindowId); + CopyWindowToVram(data->playerNameAndIdWindowId, 2); CopyBgTilemapBufferToVram(0); - data->field_F = 0; + data->leaderId = 0; data->state = 3; break; case 3: - id = sub_8116FE4(); + id = GetNewLeaderCandidate(); switch (id) { case 1: @@ -2209,16 +2333,16 @@ static void sub_8117F20(u8 taskId) { // this unused variable along with the assignment is needed to match u32 unusedVar; - unusedVar = data->field_0->arr[id].unk.gname.unk_0a_0; + unusedVar = data->field_0->arr[id].gname_uname.gname.activity; - if (data->field_0->arr[id].field_1A_0 == 1 && !data->field_0->arr[id].unk.gname.unk_0a_7) + if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started) { - data->field_F = id; + data->leaderId = id; LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); RedrawListMenu(data->listTaskId); - IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]); - sub_80FBF54(data->field_0->arr[data->field_F].unk.playerName, ReadAsU16(data->field_0->arr[data->field_F].unk.gname.unk_00.playerTrainerId)); + IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]); + CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId)); PlaySE(SE_PN_ON); data->state = 4; } @@ -2236,17 +2360,17 @@ static void sub_8117F20(u8 taskId) break; case 4: AddTextPrinterToWindow1(gUnknown_8459238); - IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]); + IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]); data->state = 5; break; case 5: if (gReceivedRemoteLinkPlayers != 0) { - gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0; + sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity; data->state = 10; } - switch (sub_80FB9F4()) + switch (RfuGetErrorStatus()) { case 1: case 2: @@ -2255,7 +2379,7 @@ static void sub_8117F20(u8 taskId) break; case 5: AddTextPrinterToWindow1(gUnknown_84576AC); - sub_80FB9E4(0, 0); + RfuSetErrorStatus(0, 0); break; } break; @@ -2264,19 +2388,19 @@ static void sub_8117F20(u8 taskId) case 10: DestroyListMenuTask(data->listTaskId, 0, 0); CopyBgTilemapBufferToVram(0); - RemoveWindow(data->field_D); + RemoveWindow(data->playerNameAndIdWindowId); RemoveWindow(data->listWindowId); - DestroyTask(data->field_11); + DestroyTask(data->listenTaskId); Free(data->field_0); Free(data->field_4); data->state++; break; case 9: - if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_8457838[sub_80FB9F4()])) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_8457838[RfuGetErrorStatus()])) { DestroyWirelessStatusIndicatorSprite(); DestroyTask(taskId); - sub_80F8DC0(); + LinkRfu_Shutdown(); gSpecialVar_Result = 5; } break; @@ -2284,12 +2408,12 @@ static void sub_8117F20(u8 taskId) DestroyWirelessStatusIndicatorSprite(); AddTextPrinterToWindow1(gUnknown_84571B8); DestroyTask(taskId); - sub_80F8DC0(); + LinkRfu_Shutdown(); gSpecialVar_Result = 5; break; case 11: data->state++; - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); break; case 12: if (IsLinkTaskFinished()) @@ -2298,22 +2422,22 @@ static void sub_8117F20(u8 taskId) } } -void MEvent_CreateTask_CardOrNewsOverWireless(u32 arg0) +void MEvent_CreateTask_CardOrNewsOverWireless(u32 activity) { u8 taskId; struct UnkStruct_Group * dataPtr; - taskId = CreateTask(sub_81182DC, 0); + taskId = CreateTask(Task_CardOrNewsOverWireless, 0); sUnionRoomMain.group = dataPtr = (void*)(gTasks[taskId].data); sGroup = dataPtr; dataPtr->state = 0; dataPtr->textState = 0; - dataPtr->field_12 = arg0 - 21; + dataPtr->cardOrNews = activity - ACTIVITY_WCARD2; // 0: Card; 1: News gSpecialVar_Result = 0; } -static void sub_81182DC(u8 taskId) +static void Task_CardOrNewsOverWireless(u8 taskId) { s32 id; struct WindowTemplate winTemplate; @@ -2323,9 +2447,9 @@ static void sub_81182DC(u8 taskId) { case 0: SetHostRFUtgtGname(0, 0, 0); - sub_800B1F4(); + SetWirelessCommType1(); OpenLink(); - sub_80FBBD8(); + InitializeRfuLinkManager_JoinGroup(); data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20)); data->state = 1; @@ -2335,29 +2459,29 @@ static void sub_81182DC(u8 taskId) data->state = 2; break; case 2: - sub_811A650(data->field_4->arr, 4); - sub_811A5E4(data->field_0->arr, 16); - data->field_11 = sub_811A084(data->field_4, data->field_12 + 7); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x20Array(data->field_0->arr, 16); + data->listenTaskId = CreateTask_ListenForPartnersWithSerial7F7D(data->field_4, data->cardOrNews + LINK_GROUP_WONDER_CARD); if (data->field_13 != 0) { - winTemplate = gUnknown_8456D4C; + winTemplate = sWindowTemplate_MysteryGiftList; winTemplate.baseBlock = GetMysteryGiftBaseBlock(); data->listWindowId = AddWindow(&winTemplate); MG_DrawTextBorder(data->listWindowId); - gMultiuseListMenuTemplate = gUnknown_8456DDC; + gMultiuseListMenuTemplate = sListMenuTemplate_UnionRoomGroups; gMultiuseListMenuTemplate.windowId = data->listWindowId; data->listTaskId = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); CopyBgTilemapBufferToVram(0); } - data->field_F = 0; + data->leaderId = 0; data->state = 3; break; case 3: - id = sub_8116FE4(); + id = GetNewLeaderCandidate(); switch (id) { case 1: @@ -2369,17 +2493,17 @@ static void sub_81182DC(u8 taskId) case 0: if (data->field_13 != 0) id = ListMenu_ProcessInput(data->listTaskId); - if (data->field_14 > 120) + if (data->refreshTimer > 120) { - if (data->field_0->arr[0].field_1A_0 == 1 && !data->field_0->arr[0].unk.gname.unk_0a_7) + if (data->field_0->arr[0].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[0].gname_uname.gname.started) { - if (sub_8119FB0(&data->field_0->arr[0].unk.gname, data->field_12 + 7)) + if (GetGnameWonderFlagByLinkGroup(&data->field_0->arr[0].gname_uname.gname, data->cardOrNews + LINK_GROUP_WONDER_CARD)) { - data->field_F = 0; - data->field_14 = 0; + data->leaderId = 0; + data->refreshTimer = 0; LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); - sub_80FBF54(data->field_0->arr[0].unk.playerName, ReadAsU16(data->field_0->arr[0].unk.gname.unk_00.playerTrainerId)); + CreateTask_RfuReconnectWithParent(data->field_0->arr[0].gname_uname.uname, ReadAsU16(data->field_0->arr[0].gname_uname.gname.unk_00.playerTrainerId)); PlaySE(SE_PN_ON); data->state = 4; } @@ -2393,25 +2517,25 @@ static void sub_81182DC(u8 taskId) else if (JOY_NEW(B_BUTTON)) { data->state = 6; - data->field_14 = 0; + data->refreshTimer = 0; } - data->field_14++; + data->refreshTimer++; break; } break; case 4: AddTextPrinterToWindow1(gUnknown_845928C); - IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->field_F]); + IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]); data->state = 5; break; case 5: if (gReceivedRemoteLinkPlayers != 0) { - gUnknown_203B058 = data->field_0->arr[data->field_F].unk.gname.unk_0a_0; + sPlayerCurrActivity = data->field_0->arr[data->leaderId].gname_uname.gname.activity; data->state = 12; } - switch (sub_80FB9F4()) + switch (RfuGetErrorStatus()) { case 1: case 2: @@ -2420,7 +2544,7 @@ static void sub_81182DC(u8 taskId) break; case 5: AddTextPrinterToWindow1(gUnknown_845777C); - sub_80FB9E4(0, 0); + RfuSetErrorStatus(0, 0); break; } break; @@ -2434,7 +2558,7 @@ static void sub_81182DC(u8 taskId) CopyBgTilemapBufferToVram(0); RemoveWindow(data->listWindowId); } - DestroyTask(data->field_11); + DestroyTask(data->listenTaskId); Free(data->field_0); Free(data->field_4); data->state++; @@ -2444,7 +2568,7 @@ static void sub_81182DC(u8 taskId) { DestroyWirelessStatusIndicatorSprite(); DestroyTask(taskId); - sub_80F8DC0(); + LinkRfu_Shutdown(); gSpecialVar_Result = 5; } break; @@ -2453,22 +2577,22 @@ static void sub_81182DC(u8 taskId) { DestroyWirelessStatusIndicatorSprite(); DestroyTask(taskId); - sub_80F8DC0(); + LinkRfu_Shutdown(); gSpecialVar_Result = 5; } break; case 11: - if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_845933C[data->field_12])) + if (MG_PrintTextOnWindow1AndWaitButton(&data->textState, gUnknown_845933C[data->cardOrNews])) { DestroyWirelessStatusIndicatorSprite(); DestroyTask(taskId); - sub_80F8DC0(); + LinkRfu_Shutdown(); gSpecialVar_Result = 5; } break; case 13: data->state++; - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); break; case 14: if (IsLinkTaskFinished()) @@ -2482,7 +2606,7 @@ void UnionRoomSpecial(void) struct UnkStruct_URoom * dataPtr; ClearAndInitHostRFUtgtGname(); - CreateTask(sub_81186E0, 10); + CreateTask(Task_RunUnionRoom, 10); // dumb line needed to match sUnionRoomMain.uRoom = sUnionRoomMain.uRoom; @@ -2497,7 +2621,7 @@ void UnionRoomSpecial(void) dataPtr->field_12 = 0; gSpecialVar_Result = 0; - sub_8107D38(0xD0, 1); + ListMenuLoadStdPalAt(0xD0, 1); } static u16 ReadAsU16(const u8 *ptr) @@ -2505,7 +2629,7 @@ static u16 ReadAsU16(const u8 *ptr) return (ptr[1] << 8) | (ptr[0]); } -static void sub_8118664(u32 nextState, const u8 *src) +static void UnionRoom_ScheduleFieldMessageWithFollowupState(u32 nextState, const u8 *src) { struct UnkStruct_URoom * data = sUnionRoomMain.uRoom; @@ -2515,7 +2639,7 @@ static void sub_8118664(u32 nextState, const u8 *src) StringExpandPlaceholders(gStringVar4, src); } -static void sub_811868C(const u8 *src) +static void UnionRoom_ScheduleFieldMessageAndExit(const u8 *src) { struct UnkStruct_URoom * data = sUnionRoomMain.uRoom; @@ -2524,17 +2648,17 @@ static void sub_811868C(const u8 *src) StringExpandPlaceholders(gStringVar4, src); } -static void sub_81186B0(struct UnkStruct_URoom * data) +static void BackUpURoomField0ToDecompressionBuffer(struct UnkStruct_URoom * data) { - memcpy(&gDecompressionBuffer[0x3F00], data->field_0, 8 * sizeof(struct UnkStruct_x20)); + memcpy(&gDecompressionBuffer[0x3F00], data->field_0, UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20)); } -static void sub_81186C8(struct UnkStruct_URoom * data) +static void RestoreURoomField0FromDecompressionBuffer(struct UnkStruct_URoom * data) { - memcpy(data->field_0, &gDecompressionBuffer[0x3F00], 8 * sizeof(struct UnkStruct_x20)); + memcpy(data->field_0, &gDecompressionBuffer[0x3F00], UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20)); } -static void sub_81186E0(u8 taskId) +static void Task_RunUnionRoom(u8 taskId) { u32 id = 0; s32 var5 = 0; @@ -2545,53 +2669,53 @@ static void sub_81186E0(u8 taskId) switch (data->state) { case 0: - data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - data->field_C = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - data->field_0 = AllocZeroed(8 * sizeof(struct UnkStruct_x20)); + data->field_4 = AllocZeroed(RFU_CHILD_MAX * sizeof(struct UnkStruct_x1C)); + data->field_C = AllocZeroed(RFU_CHILD_MAX * sizeof(struct UnkStruct_x1C)); + data->field_0 = AllocZeroed(UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20)); data->field_8 = AllocZeroed(sizeof(struct UnkStruct_x20)); - sub_811A5E4(data->field_0->arr, 8); - gUnknown_203B058 = 0x40; - data->field_20 = sub_8119E84(data->field_C, data->field_4, 9); + BlankUnkStruct_x20Array(data->field_0->arr, UROOM_MAX_GROUP_COUNT); + sPlayerCurrActivity = IN_UNION_ROOM; + data->field_20 = CreateTask_SearchForChildOrParent(data->field_C, data->field_4, LINK_GROUP_UNION_ROOM_RESUME); ZeroUnionObjWork(data->unionObjs); - sub_811BB68(); + MakeGroupAssemblyAreasPassable(); data->state = 1; break; case 1: - sub_811BAAC(data->spriteIds, taskData[0]); + CreateGroupMemberObjectsInvisible(data->spriteIds, taskData[0]); if (++taskData[0] == 8) data->state = 2; break; case 2: - SetHostRFUtgtGname(0x40, 0, 0); - sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); - sub_800B1F4(); + SetHostRFUtgtGname(IN_UNION_ROOM, 0, 0); + RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + SetWirelessCommType1(); OpenLink(); - sub_80FBC00(); - sub_811A5E4(&data->field_8->arr[0], 1); - sub_811A650(data->field_4->arr, 4); - sub_811A650(data->field_C->arr, 4); + InitializeRfuLinkManager_EnterUnionRoom(); + BlankUnkStruct_x20Array(&data->field_8->arr[0], 1); + BlankUnkStruct_x1CArray(data->field_4->arr, 4); + BlankUnkStruct_x1CArray(data->field_C->arr, 4); gSpecialVar_Result = 0; data->state = 3; break; case 3: if ((GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_REGISTER - || GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_TRADE) + || GetPartyMenuType() == PARTY_MENU_TYPE_UNION_ROOM_TRADE) && sUnionRoomTrade.field_0 != 0) { id = GetCursorSelectionMonId(); switch (sUnionRoomTrade.field_0) { case 1: - sub_80FB008(0x54, 0, 1); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); if (id >= PARTY_SIZE) { ResetUnionRoomTrade(&sUnionRoomTrade); - sub_80FAFA0(0, 0, 0); - sub_811868C(gUnknown_8458D54); + RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D54); } else if (!RegisterTradeMonAndGetIsEgg(GetCursorSelectionMonId(), &sUnionRoomTrade)) { - sub_8118664(0x34, gUnknown_8458CD4); + UnionRoom_ScheduleFieldMessageWithFollowupState(52, gURText_PleaseChooseTypeOfMon); } else { @@ -2599,16 +2723,16 @@ static void sub_81186E0(u8 taskId) } break; case 2: - sub_81186C8(data); + RestoreURoomField0FromDecompressionBuffer(data); taskData[1] = sUnionRoomTrade.field_8; if (id >= PARTY_SIZE) { - sub_811868C(gUnknown_8458D9C); + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D9C); } else { - sub_80FB008(0x54, 0, 1); - gUnknown_203B058 = 0x44; + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM; RegisterTradeMon(GetCursorSelectionMonId(), &sUnionRoomTrade); data->state = 51; } @@ -2626,7 +2750,7 @@ static void sub_81186E0(u8 taskId) { if (gSpecialVar_Result == 9) { - sub_80FB008(0x54, 0, 1); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); PlaySE(SE_PC_LOGIN); StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); data->state = 42; @@ -2634,7 +2758,7 @@ static void sub_81186E0(u8 taskId) } else if (gSpecialVar_Result == 11) { - sub_80FB008(0x54, 0, 1); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); data->state = 23; gSpecialVar_Result = 0; } @@ -2650,98 +2774,98 @@ static void sub_81186E0(u8 taskId) { if (JOY_NEW(A_BUTTON)) { - if (sub_811BF00(data->field_0, &taskData[0], &taskData[1], data->spriteIds)) + if (RfuUnionTool_GetGroupAndMemberInFrontOfPlayer(data->field_0, &taskData[0], &taskData[1], data->spriteIds)) { PlaySE(SE_SELECT); - sub_811B298(); + UR_EnableScriptContext2AndFreezeObjectEvents(); data->state = 24; break; } - else if (sub_811A9B8()) + else if (PlayerIsTalkingToUnionRoomAide()) { - sub_80FB008(0x54, 0, 1); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); PlaySE(SE_PC_LOGIN); - sub_811B298(); + UR_EnableScriptContext2AndFreezeObjectEvents(); StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); data->state = 45; break; } } - switch (sub_8119B94()) + switch (HandlePlayerListUpdate()) { case 1: PlaySE(SE_TOY_C); case 2: - sub_811BECC(data); + ScheduleUnionRoomPlayerRefresh(data); break; case 4: data->state = 11; - sub_811B298(); - sub_80FAFA0(0, 0, 0); - sub_80FB008(0x53, sub_811B2D8(data), 0); + UR_EnableScriptContext2AndFreezeObjectEvents(); + RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_NPCTALK | IN_UNION_ROOM, GetActivePartnerSpriteGenderParam(data), FALSE); break; } - sub_811BEDC(data); + HandleUnionRoomPlayerRefresh(data); } break; case 23: if (!FuncIsActiveTask(Task_StartMenuHandleInput)) { - sub_80FB008(0x40, 0, 0); + UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE); data->state = 4; } break; case 24: - sub_811A0E0(); + UR_RunTextPrinters_CheckPrinter0Active(); playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_80FB008(0x54, 0, 1); - switch (sub_811AA5C(data->field_0, taskData[0], taskData[1], playerGender)) + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + switch (UnionRoomGetPlayerInteractionResponse(data->field_0, taskData[0], taskData[1], playerGender)) { case 0: data->state = 26; break; case 1: - sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, gUnknown_203B058); + sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); data->field_12 = id; // Should be just 0, but won't match any other way. data->state = 25; break; case 2: - sub_8118664(0x13, gStringVar4); + UnionRoom_ScheduleFieldMessageWithFollowupState(19, gStringVar4); break; } break; case 25: - sub_811A0E0(); - switch (sub_80FB9F4()) + UR_RunTextPrinters_CheckPrinter0Active(); + switch (RfuGetErrorStatus()) { case 4: - sub_811B258(TRUE); + HandleCancelTrade(TRUE); data->state = 4; break; case 1: case 2: - if (sub_80FBB0C() == TRUE) - sub_811868C(gUnknown_8457F90); + if (IsUnionRoomListenTaskActive() == TRUE) + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8457F90); else - sub_8118664(30, gUnknown_8457F90); + UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_8457F90); - gUnknown_203B058 = 0x40; + sPlayerCurrActivity = IN_UNION_ROOM; break; } if (gReceivedRemoteLinkPlayers != 0) { - sub_8117594(gBlockSendBuffer, TRUE); - CreateTask(sub_8117280, 5); + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); + CreateTask(Task_ExchangeCards, 5); data->state = 38; } break; case 38: - if (!FuncIsActiveTask(sub_8117280)) + if (!FuncIsActiveTask(Task_ExchangeCards)) { - if (gUnknown_203B058 == 0x44) - sub_8118664(31, gUnknown_84578BC); + if (sPlayerCurrActivity == (ACTIVITY_TRADE | IN_UNION_ROOM)) + UnionRoom_ScheduleFieldMessageWithFollowupState(31, gUnknown_84578BC); else data->state = 5; } @@ -2749,18 +2873,18 @@ static void sub_81186E0(u8 taskId) case 30: if (gReceivedRemoteLinkPlayers == 0) { - sub_811B258(FALSE); - sub_811C028(taskData[0], taskData[1], data->field_0); + HandleCancelTrade(FALSE); + UpdateUnionGroupMemberFacing(taskData[0], taskData[1], data->field_0); data->state = 2; } break; case 5: - id = sub_811AA24(&data->field_0->arr[taskData[1]]); + id = ConvPartnerUnameAndGetWhetherMetAlready(&data->field_0->arr[taskData[1]]); playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_8118664(6, gUnknown_8457B04[id][playerGender]); + UnionRoom_ScheduleFieldMessageWithFollowupState(6, gURText_FriendPromptsForActivity[id][playerGender]); break; case 6: - var5 = sub_811A218(&data->textState, &data->field_1B, &data->field_1C, &gUnknown_8456DF4, &gUnknown_8456E1C); + var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->topListMenuWindowId, &data->topListMenuListMenuId, &sWindowTemplate_InviteToActivity, &sListMenuTemplate_InviteToActivity); if (var5 != -1) { if (gReceivedRemoteLinkPlayers == 0) @@ -2769,27 +2893,27 @@ static void sub_81186E0(u8 taskId) } else { - data->field_98 = 0; + data->partnerYesNoResponse = 0; playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - if (var5 == -2 || var5 == 0x40) + if (var5 == -2 || var5 == IN_UNION_ROOM) { - data->field_4C[0] = 0x40; - sub_80F9E2C(data->field_4C); + data->playerSendBuffer[0] = IN_UNION_ROOM; + RfuPrepareSend0x2f00(data->playerSendBuffer); StringCopy(gStringVar4, gUnknown_845842C[gLinkPlayers[0].gender]); data->state = 32; } else { - gUnknown_203B058 = var5; - gUnknown_203B059 = (u32)(var5) >> 8; - if (gUnknown_203B058 == 0x41 && !HasAtLeastTwoMonsOfLevel30OrLower()) + sPlayerCurrActivity = var5; + sPlayerActivityGroupSize = (u32)(var5) >> 8; + if (sPlayerCurrActivity == (ACTIVITY_BATTLE | IN_UNION_ROOM) && !HasAtLeastTwoMonsOfLevel30OrLower()) { - sub_8118664(5, gUnknown_845847C); + UnionRoom_ScheduleFieldMessageWithFollowupState(5, gUnknown_845847C); } else { - data->field_4C[0] = gUnknown_203B058 | 0x40; - sub_80F9E2C(data->field_4C); + data->playerSendBuffer[0] = sPlayerCurrActivity | IN_UNION_ROOM; + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 27; } } @@ -2801,24 +2925,24 @@ static void sub_81186E0(u8 taskId) data->state = 36; break; case 27: - sub_811B0A4(data); + PollPartnerYesNoResponse(data); playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - id = sub_811A9FC(data->field_4C[0] & 0x3F); - if (PrintOnTextbox(&data->textState, gUnknown_84580F4[playerGender][id])) + id = GetResponseIdx_InviteToURoomActivity(data->playerSendBuffer[0] & 0x3F); + if (PrintOnTextbox(&data->textState, gResponseToURoomActivityInviteStringPtrs[playerGender][id])) { taskData[3] = 0; data->state = 29; } break; case 32: - sub_800AAC0(); + Link_TryStartSend5FFF(); data->state = 36; break; case 31: - data->field_4C[0] = 0x44; - data->field_4C[1] = sUnionRoomTrade.species; - data->field_4C[2] = sUnionRoomTrade.level; - sub_80F9E2C(data->field_4C); + data->playerSendBuffer[0] = ACTIVITY_TRADE | IN_UNION_ROOM; + data->playerSendBuffer[1] = sUnionRoomTrade.species; + data->playerSendBuffer[2] = sUnionRoomTrade.level; + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 29; break; case 29: @@ -2829,12 +2953,12 @@ static void sub_81186E0(u8 taskId) } else { - sub_811B0A4(data); - if (data->field_98 == 0x51) + PollPartnerYesNoResponse(data); + if (data->partnerYesNoResponse == (ACTIVITY_ACCEPT | IN_UNION_ROOM)) { - if (gUnknown_203B058 == 8) + if (sPlayerCurrActivity == ACTIVITY_CARD) { - sub_811B31C(gStringVar4, data, FALSE); + ViewURoomPartnerTrainerCard(gStringVar4, data, MODE_CHILD); data->state = 40; } else @@ -2842,27 +2966,27 @@ static void sub_81186E0(u8 taskId) data->state = 13; } } - else if (data->field_98 == 0x52) + else if (data->partnerYesNoResponse == (ACTIVITY_DECLINE | IN_UNION_ROOM)) { data->state = 32; - sub_811AE68(gStringVar4, gUnknown_203B058 | 0x40, gLinkPlayers[0].gender); - gUnknown_203B058 = 0; + GetURoomActivityRejectMsg(gStringVar4, sPlayerCurrActivity | IN_UNION_ROOM, gLinkPlayers[0].gender); + sPlayerCurrActivity = 0; } } break; case 7: - id = sub_811AA24(&data->field_0->arr[taskData[1]]); + id = ConvPartnerUnameAndGetWhetherMetAlready(&data->field_0->arr[taskData[1]]); playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_8118664(6, gUnknown_8457B04[id][playerGender]); + UnionRoom_ScheduleFieldMessageWithFollowupState(6, gURText_FriendPromptsForActivity[id][playerGender]); break; case 40: if (PrintOnTextbox(&data->textState, gStringVar4)) { data->state = 41; - sub_800AB9C(); - data->field_98 = 0; - data->field_9A[0] = 0; + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); + data->partnerYesNoResponse = 0; + data->recvActivityRequest[0] = 0; } break; case 41: @@ -2882,13 +3006,13 @@ static void sub_81186E0(u8 taskId) } break; case 19: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: CopyBgTilemapBufferToVram(0); - gUnknown_203B058 = 0x45; - sub_80FB008(0x45, 0, 1); - sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, gUnknown_203B058); + sPlayerCurrActivity = ACTIVITY_CHAT | IN_UNION_ROOM; + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, 0, TRUE); + sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); data->field_12 = taskData[1]; data->state = 20; taskData[3] = 0; @@ -2896,7 +3020,7 @@ static void sub_81186E0(u8 taskId) case 1: case -1: playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_811868C(gUnknown_8458548[playerGender]); + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458548[playerGender]); break; } break; @@ -2908,20 +3032,20 @@ static void sub_81186E0(u8 taskId) } break; case 21: - switch (sub_80FB9F4()) + switch (RfuGetErrorStatus()) { case 4: - sub_811B258(TRUE); + HandleCancelTrade(TRUE); data->state = 4; break; case 1: case 2: playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_80FB008(0x54, 0, 1); - if (sub_80FBB0C() == TRUE) - sub_811868C(gUnknown_84585E8[playerGender]); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + if (IsUnionRoomListenTaskActive() == TRUE) + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_84585E8[playerGender]); else - sub_8118664(30, gUnknown_84585E8[playerGender]); + UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_84585E8[playerGender]); break; case 3: data->state = 22; @@ -2930,14 +3054,14 @@ static void sub_81186E0(u8 taskId) taskData[3]++; break; case 22: - if (sub_80FBA00()) + if (RfuIsErrorStatus1or2()) { playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - sub_80FB008(0x54, 0, 1); - if (sub_80FBB0C() == TRUE) - sub_811868C(gUnknown_84585E8[playerGender]); + UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + if (IsUnionRoomListenTaskActive() == TRUE) + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_84585E8[playerGender]); else - sub_8118664(30, gUnknown_84585E8[playerGender]); + UnionRoom_ScheduleFieldMessageWithFollowupState(30, gUnknown_84585E8[playerGender]); } if (gReceivedRemoteLinkPlayers != 0) data->state = 16; @@ -2946,24 +3070,24 @@ static void sub_81186E0(u8 taskId) PlaySE(SE_PINPON); sub_80F8FA0(); data->state = 12; - data->field_9A[0] = 0; + data->recvActivityRequest[0] = 0; break; case 12: - if (sub_80FBA00()) + if (RfuIsErrorStatus1or2()) { - sub_811B258(FALSE); + HandleCancelTrade(FALSE); data->state = 2; } else if (gReceivedRemoteLinkPlayers != 0) { - sub_8117594(gBlockSendBuffer, TRUE); - CreateTask(sub_8117280, 5); + CreateTrainerCardInBuffer(gBlockSendBuffer, TRUE); + CreateTask(Task_ExchangeCards, 5); data->state = 39; } break; case 39: - sub_8119904(data); - if (!FuncIsActiveTask(sub_8117280)) + ReceiveUnionRoomActivityPacket(data); + if (!FuncIsActiveTask(Task_ExchangeCards)) { data->state = 33; StringCopy(gStringVar1, gLinkPlayers[1].name); @@ -2972,13 +3096,13 @@ static void sub_81186E0(u8 taskId) } break; case 33: - sub_8119904(data); + ReceiveUnionRoomActivityPacket(data); if (PrintOnTextbox(&data->textState, gStringVar4)) data->state = 34; break; case 34: - sub_8119904(data); - if (sub_8119944(data) && JOY_NEW(B_BUTTON)) + ReceiveUnionRoomActivityPacket(data); + if (UnionRoom_HandleContactFromOtherPlayer(data) && JOY_NEW(B_BUTTON)) { sub_80FBD6C(1); StringCopy(gStringVar4, gUnknown_8457E60); @@ -2986,80 +3110,82 @@ static void sub_81186E0(u8 taskId) } break; case 35: - sub_8118664(9, gStringVar4); + // You said yes + UnionRoom_ScheduleFieldMessageWithFollowupState(9, gStringVar4); break; case 9: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: - data->field_4C[0] = 0x51; - if (gUnknown_203B058 == 0x45) - sub_80FB008(gUnknown_203B058 | 0x40, sub_811B2A8(1), 0); + data->playerSendBuffer[0] = ACTIVITY_ACCEPT | IN_UNION_ROOM; + if (sPlayerCurrActivity == (ACTIVITY_CHAT | IN_UNION_ROOM)) + UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), FALSE); else - sub_80FB008(gUnknown_203B058 | 0x40, sub_811B2A8(1), 1); + UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), TRUE); data->field_8->arr[0].field_1B = 0; taskData[3] = 0; - if (gUnknown_203B058 == 0x41) + if (sPlayerCurrActivity == (ACTIVITY_BATTLE | IN_UNION_ROOM)) { if (!HasAtLeastTwoMonsOfLevel30OrLower()) { - data->field_4C[0] = 0x52; - sub_80F9E2C(data->field_4C); + data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM; + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 10; StringCopy(gStringVar4, gUnknown_84584C0); } else { - sub_80F9E2C(data->field_4C); + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 13; } } - else if (gUnknown_203B058 == 0x48) + else if (sPlayerCurrActivity == (ACTIVITY_CARD | IN_UNION_ROOM)) { - sub_80F9E2C(data->field_4C); - sub_811B31C(gStringVar4, data, 1); + RfuPrepareSend0x2f00(data->playerSendBuffer); + ViewURoomPartnerTrainerCard(gStringVar4, data, MODE_PARENT); data->state = 40; } else { - sub_80F9E2C(data->field_4C); + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 13; } break; case 1: case -1: - data->field_4C[0] = 0x52; - sub_80F9E2C(data->field_4C); + data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM; + RfuPrepareSend0x2f00(data->playerSendBuffer); data->state = 10; - sub_81162E0(gStringVar4, gUnknown_203B058); + GetYouDeclinedTheOfferMessage(gStringVar4, sPlayerCurrActivity); break; } break; case 10: - sub_800AAC0(); + Link_TryStartSend5FFF(); data->state = 36; break; case 36: + // You said no if (gReceivedRemoteLinkPlayers == 0) { - gUnknown_203B058 = 0x40; - sub_8118664(0x25, gStringVar4); - memset(data->field_4C, 0, sizeof(data->field_4C)); - data->field_9A[0] = 0; - data->field_98 = 0; + sPlayerCurrActivity = IN_UNION_ROOM; + UnionRoom_ScheduleFieldMessageWithFollowupState(37, gStringVar4); + memset(data->playerSendBuffer, 0, sizeof(data->playerSendBuffer)); + data->recvActivityRequest[0] = 0; + data->partnerYesNoResponse = 0; } break; case 37: data->state = 2; - sub_811B258(FALSE); + HandleCancelTrade(FALSE); break; case 13: - sub_811AECC(gStringVar4, gUnknown_203B058 | 0x40); - sub_8118664(14, gStringVar4); + GetURoomActivityStartMsg(gStringVar4, sPlayerCurrActivity | IN_UNION_ROOM); + UnionRoom_ScheduleFieldMessageWithFollowupState(14, gStringVar4); break; case 14: - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); data->state = 15; break; case 15: @@ -3072,7 +3198,7 @@ static void sub_81186E0(u8 taskId) Free(data->field_C); Free(data->field_4); DestroyTask(data->field_20); - sub_811BB40(data->spriteIds); + DestroyGroupMemberObjects(data->spriteIds); data->state = 17; break; case 17: @@ -3082,30 +3208,30 @@ static void sub_81186E0(u8 taskId) case 18: if (!UpdatePaletteFade()) { - sub_811BA78(); + DeleteUnionObjWorkAndStopTask(); DestroyTask(taskId); Free(sUnionRoomMain.uRoom); - sub_81179A4(); + CreateTask_StartActivity(); } break; case 42: - if (sub_80F9800()->species == SPECIES_NONE) + if (GetHostRFUtgtGname()->species == SPECIES_NONE) { data->state = 43; } else { - if (sub_80F9800()->species == SPECIES_EGG) + if (GetHostRFUtgtGname()->species == SPECIES_EGG) { StringCopy(gStringVar4, gUnknown_8458DE8); } else { - StringCopy(gStringVar1, gSpeciesNames[sub_80F9800()->species]); - ConvertIntToDecimalStringN(gStringVar2, sub_80F9800()->level, STR_CONV_MODE_LEFT_ALIGN, 3); + StringCopy(gStringVar1, gSpeciesNames[GetHostRFUtgtGname()->species]); + ConvertIntToDecimalStringN(gStringVar2, GetHostRFUtgtGname()->level, STR_CONV_MODE_LEFT_ALIGN, 3); StringExpandPlaceholders(gStringVar4, gUnknown_8458DBC); } - sub_8118664(44, gStringVar4); + UnionRoom_ScheduleFieldMessageWithFollowupState(44, gStringVar4); } break; case 43: @@ -3113,23 +3239,23 @@ static void sub_81186E0(u8 taskId) data->state = 47; break; case 47: - var5 = sub_811A218(&data->textState, &data->field_1D, &data->field_1E, &gUnknown_8456E34, &gUnknown_8456E54); + var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardDetailsWindowId, &sWindowTemplate_TradeBoardRegisterInfoExit, &sListMenuTemplate_TradeBoardRegisterInfoExit); if (var5 != -1) { if (var5 == -2 || var5 == 3) { data->state = 4; - sub_811B258(TRUE); + HandleCancelTrade(TRUE); } else { switch (var5) { case 1: // REGISTER - sub_8118664(53, gUnknown_8458D1C); + UnionRoom_ScheduleFieldMessageWithFollowupState(53, gUnknown_8458D1C); break; case 2: // INFO - sub_8118664(47, gUnknown_8458B44); + UnionRoom_ScheduleFieldMessageWithFollowupState(47, gUnknown_8458B44); break; } } @@ -3149,7 +3275,7 @@ static void sub_81186E0(u8 taskId) } break; case 52: - var5 = sub_811A218(&data->textState, &data->field_1D, &data->field_1E, &gUnknown_8456E6C, &gUnknown_8456F04); + var5 = ListMenuHandler_AllItemsAvailable(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardDetailsWindowId, &sWindowTemplate_TypeNames, &sListMenuTemplate_TypeNames); if (var5 != -1) { switch (var5) @@ -3157,8 +3283,8 @@ static void sub_81186E0(u8 taskId) case -2: case 18: ResetUnionRoomTrade(&sUnionRoomTrade); - sub_80FAFA0(0, 0, 0); - sub_811868C(gUnknown_8458D54); + RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D54); break; default: sUnionRoomTrade.type = var5; @@ -3168,18 +3294,18 @@ static void sub_81186E0(u8 taskId) } break; case 55: - sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); - sub_811868C(gUnknown_8458D78); + RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + UnionRoom_ScheduleFieldMessageAndExit(gUnknown_8458D78); break; case 44: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: data->state = 56; break; case 1: case -1: - sub_811B258(TRUE); + HandleCancelTrade(TRUE); data->state = 4; break; } @@ -3187,9 +3313,9 @@ static void sub_81186E0(u8 taskId) case 56: if (PrintOnTextbox(&data->textState, gUnknown_8458E10)) { - sub_80FAFA0(0, 0, 0); + RfuUpdatePlayerGnameStateAndSend(0, 0, 0); ResetUnionRoomTrade(&sUnionRoomTrade); - sub_811B258(TRUE); + HandleCancelTrade(TRUE); data->state = 4; } break; @@ -3198,38 +3324,38 @@ static void sub_81186E0(u8 taskId) data->state = 46; break; case 46: - sub_811A3F8(); + UR_BlankBg0(); data->state = 48; break; case 48: - var5 = sub_811A2EC(&data->textState, &data->field_1D, &data->field_4A, &data->field_1E, &gUnknown_8456F24, &gUnknown_8456F7C, data->field_0); + var5 = TradeBoardMenuHandler(&data->textState, &data->tradeBoardSelectWindowId, &data->tradeBoardListMenuId, &data->tradeBoardDetailsWindowId, &gUnknown_8456F24, &sTradeBoardListMenuTemplate, data->field_0); if (var5 != -1) { switch (var5) { case -2: case 8: - sub_811B258(TRUE); + HandleCancelTrade(TRUE); DestroyHelpMessageWindow_(); data->state = 4; break; default: - switch (sub_811ADD0(data->field_0->arr[var5].unk.gname.type, data->field_0->arr[var5].unk.gname.species)) + switch (IsRequestedTypeAndSpeciesInPlayerParty(data->field_0->arr[var5].gname_uname.gname.type, data->field_0->arr[var5].gname_uname.gname.species)) { - case 0: + case UR_TRADE_MATCH: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); - sub_8118664(49, gUnknown_8458E70); + UnionRoom_ScheduleFieldMessageWithFollowupState(49, gUnknown_8458E70); taskData[1] = var5; break; - case 1: + case UR_TRADE_NOTYPE: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); - StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].unk.gname.type]); - sub_8118664(46, gUnknown_8458ED0); + StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]); + UnionRoom_ScheduleFieldMessageWithFollowupState(46, gUnknown_8458ED0); break; - case 2: + case UR_TRADE_NOEGG: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); - StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].unk.gname.type]); - sub_8118664(46, gUnknown_8458F04); + StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]); + UnionRoom_ScheduleFieldMessageWithFollowupState(46, gUnknown_8458F04); break; } break; @@ -3237,14 +3363,14 @@ static void sub_81186E0(u8 taskId) } break; case 49: - switch (sub_811A14C(&data->textState, FALSE)) + switch (UnionRoomHandleYesNo(&data->textState, FALSE)) { case 0: data->state = 50; break; case -1: case 1: - sub_811B258(TRUE); + HandleCancelTrade(TRUE); data->state = 4; break; } @@ -3253,27 +3379,27 @@ static void sub_81186E0(u8 taskId) if (PrintOnTextbox(&data->textState, gUnknown_8458D1C)) { sUnionRoomTrade.field_0 = 2; - memcpy(&gUnknown_203B064, &data->field_0->arr[taskData[1]].unk.gname.unk_00, sizeof(gUnknown_203B064)); - gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].unk.gname.type; - gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].unk.gname.species; + memcpy(&gPartnerTgtGnameSub, &data->field_0->arr[taskData[1]].gname_uname.gname.unk_00, sizeof(gPartnerTgtGnameSub)); + gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].gname_uname.gname.type; + gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].gname_uname.gname.species; gFieldCallback = sub_807DCE4; ChooseMonForTradingBoard(PARTY_MENU_TYPE_UNION_ROOM_TRADE, CB2_ReturnToField); - sub_81186B0(data); + BackUpURoomField0ToDecompressionBuffer(data); sUnionRoomTrade.field_8 = taskData[1]; } break; case 51: - gUnknown_203B058 = 0x44; - sub_80FC114(data->field_0->arr[taskData[1]].unk.playerName, &data->field_0->arr[taskData[1]].unk.gname, 0x44); + sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM; + sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, ACTIVITY_TRADE | IN_UNION_ROOM); IntlConvPartnerUname(gStringVar1, data->field_0->arr[taskData[1]]); - sub_811A0B4(gUnknown_8457A34[2]); + UR_PrintFieldMessage(gURText_PleaseWaitMsgs[2]); data->state = 25; break; case 26: if (PrintOnTextbox(&data->textState, gStringVar4)) { - sub_811B258(TRUE); - sub_811C028(taskData[0], taskData[1], data->field_0); + HandleCancelTrade(TRUE); + UpdateUnionGroupMemberFacing(taskData[0], taskData[1], data->field_0); data->state = 4; } break; @@ -3290,38 +3416,38 @@ void var_800D_set_xB(void) gSpecialVar_Result = 11; } -static void sub_8119904(struct UnkStruct_URoom * arg0) +static void ReceiveUnionRoomActivityPacket(struct UnkStruct_URoom * uroom) { - if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == 0x2F00) + if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == RFU_COMMAND_0x2f00) { - arg0->field_9A[0] = gRecvCmds[1][1]; - if (gRecvCmds[1][1] == 0x44) + uroom->recvActivityRequest[0] = gRecvCmds[1][1]; + if (gRecvCmds[1][1] == (ACTIVITY_TRADE | IN_UNION_ROOM)) { - arg0->field_9A[1] = gRecvCmds[1][2]; - arg0->field_9A[2] = gRecvCmds[1][3]; + uroom->recvActivityRequest[1] = gRecvCmds[1][2]; + uroom->recvActivityRequest[2] = gRecvCmds[1][3]; } } } -static bool32 sub_8119944(struct UnkStruct_URoom * arg0) +static bool32 UnionRoom_HandleContactFromOtherPlayer(struct UnkStruct_URoom * uroom) { - if (arg0->field_9A[0] != 0) + if (uroom->recvActivityRequest[0] != 0) { - s32 var = sub_811AF6C(gStringVar4, gLinkPlayers[1].gender, &arg0->field_9A[0], arg0); + s32 var = GetChatLeaderActionRequestMessage(gStringVar4, gLinkPlayers[1].gender, &uroom->recvActivityRequest[0], uroom); if (var == 0) { return TRUE; } else if (var == 1) { - arg0->state = 35; - gUnknown_203B058 = arg0->field_9A[0]; + uroom->state = 35; + sPlayerCurrActivity = uroom->recvActivityRequest[0]; return FALSE; } else if (var == 2) { - arg0->state = 36; - sub_800AAC0(); + uroom->state = 36; + Link_TryStartSend5FFF(); return FALSE; } } @@ -3336,7 +3462,7 @@ void InitUnionRoom(void) sUnionRoomPlayerName[0] = EOS; if (gQuestLogState == 2 || gQuestLogState == 3) return; - CreateTask(sub_81199FC, 0); + CreateTask(Task_InitUnionRoom, 0); sUnionRoomMain.uRoom = sUnionRoomMain.uRoom; // Needed to match. sUnionRoomMain.uRoom = ptr = AllocZeroed(sizeof(struct UnkStruct_URoom)); sURoom = sUnionRoomMain.uRoom; @@ -3347,7 +3473,7 @@ void InitUnionRoom(void) sUnionRoomPlayerName[0] = EOS; } -static void sub_81199FC(u8 taskId) +static void Task_InitUnionRoom(u8 taskId) { s32 i; u8 text[32]; @@ -3359,27 +3485,27 @@ static void sub_81199FC(u8 taskId) structPtr->state = 1; break; case 1: - SetHostRFUtgtGname(0xC, 0, 0); - sub_800B1F4(); + SetHostRFUtgtGname(ACTIVITY_SEARCH, 0, 0); + SetWirelessCommType1(); OpenLink(); - sub_80FBC00(); - sub_80FB128(1); + InitializeRfuLinkManager_EnterUnionRoom(); + sub_80FB128(TRUE); structPtr->state = 2; break; case 2: structPtr->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - sub_811A650(structPtr->field_4->arr, 4); + BlankUnkStruct_x1CArray(structPtr->field_4->arr, 4); structPtr->field_C = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); - sub_811A650(structPtr->field_C->arr, 4); - structPtr->field_0 = AllocZeroed(8 * sizeof(struct UnkStruct_x20)); - sub_811A5E4(structPtr->field_0->arr, 8); + BlankUnkStruct_x1CArray(structPtr->field_C->arr, 4); + structPtr->field_0 = AllocZeroed(UROOM_MAX_GROUP_COUNT * sizeof(struct UnkStruct_x20)); + BlankUnkStruct_x20Array(structPtr->field_0->arr, UROOM_MAX_GROUP_COUNT); structPtr->field_8 = AllocZeroed(sizeof(struct UnkStruct_x20)); - sub_811A5E4(&structPtr->field_8->arr[0], 1); - structPtr->field_20 = sub_8119E84(structPtr->field_C, structPtr->field_4, 10); + BlankUnkStruct_x20Array(&structPtr->field_8->arr[0], 1); + structPtr->field_20 = CreateTask_SearchForChildOrParent(structPtr->field_C, structPtr->field_4, LINK_GROUP_UNION_ROOM_INIT); structPtr->state = 3; break; case 3: - switch (sub_8119B94()) + switch (HandlePlayerListUpdate()) { case 1: case 2: @@ -3387,10 +3513,10 @@ static void sub_81199FC(u8 taskId) { for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++) { - if (structPtr->field_0->arr[i].field_1A_0 == 1) + if (structPtr->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { IntlConvPartnerUname(text, structPtr->field_0->arr[i]); - if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].unk.gname.unk_00.playerTrainerId), text)) + if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].gname_uname.gname.unk_00.playerTrainerId), text)) { StringCopy(sUnionRoomPlayerName, text); break; @@ -3410,7 +3536,7 @@ static void sub_81199FC(u8 taskId) Free(structPtr->field_4); DestroyTask(structPtr->field_20); Free(sUnionRoomMain.uRoom); - sub_80F8DC0(); + LinkRfu_Shutdown(); DestroyTask(taskId); break; } @@ -3430,36 +3556,41 @@ bool16 BufferUnionRoomPlayerName(void) } } -static u8 sub_8119B94(void) +static u8 HandlePlayerListUpdate(void) { s32 i; u8 j; struct UnkStruct_URoom * structPtr = sUnionRoomMain.uRoom; s32 r7 = 0; - for (i = 0; i < 4; i++) + // If someone new joined, register them in field_8 + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (sub_811A694(&structPtr->field_C->arr[i].unk0, &gUnknown_8457034) == TRUE) + if (AreGnameUnameDifferent(&structPtr->field_C->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy) == TRUE) { - structPtr->field_8->arr[0].unk = structPtr->field_C->arr[i].unk0; + structPtr->field_8->arr[0].gname_uname = structPtr->field_C->arr[i].gname_uname; structPtr->field_8->arr[0].field_18 = 0; - structPtr->field_8->arr[0].field_1A_0 = 1; + structPtr->field_8->arr[0].groupScheduledAnim = UNION_ROOM_SPAWN_IN; structPtr->field_8->arr[0].field_1B = 1; return 4; } } - for (j = 0; j < 8; j++) + + // Handle changes to existing player statuses + for (j = 0; j < UROOM_MAX_GROUP_COUNT; j++) { - if (structPtr->field_0->arr[j].field_1A_0 != 0) + if (structPtr->field_0->arr[j].groupScheduledAnim != UNION_ROOM_SPAWN_NONE) { - i = sub_811A748(&structPtr->field_0->arr[j], &structPtr->field_4->arr[0]); + i = Findx20Inx1CArray(&structPtr->field_0->arr[j], &structPtr->field_4->arr[0]); if (i != 0xFF) { - if (structPtr->field_0->arr[j].field_1A_0 == 1) + if (structPtr->field_0->arr[j].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - if (sub_811A6DC(&structPtr->field_0->arr[j].unk, &structPtr->field_4->arr[i].unk0)) + // New join in queue + if (AreUnionRoomPlayerGnamesDifferent(&structPtr->field_0->arr[j].gname_uname, &structPtr->field_4->arr[i].gname_uname)) { - structPtr->field_0->arr[j].unk = structPtr->field_4->arr[i].unk0; + // Just joined, copy their names + structPtr->field_0->arr[j].gname_uname = structPtr->field_4->arr[i].gname_uname; structPtr->field_0->arr[j].field_1B = 0x40; r7 = 1; } @@ -3472,116 +3603,121 @@ static u8 sub_8119B94(void) } else { - structPtr->field_0->arr[j].field_1A_0 = 1; + // New join, queue them + structPtr->field_0->arr[j].groupScheduledAnim = UNION_ROOM_SPAWN_IN; structPtr->field_0->arr[j].field_1B = 0; r7 = 2; } structPtr->field_0->arr[j].field_18 = 0; } - else if (structPtr->field_0->arr[j].field_1A_0 != 2) + else if (structPtr->field_0->arr[j].groupScheduledAnim != UNION_ROOM_SPAWN_OUT) { + // Person may have disconnected. Give them 10 seconds. structPtr->field_0->arr[j].field_18++; if (structPtr->field_0->arr[j].field_18 >= 600) { - structPtr->field_0->arr[j].field_1A_0 = 2; + structPtr->field_0->arr[j].groupScheduledAnim = UNION_ROOM_SPAWN_OUT; r7 = 2; } } - else if (structPtr->field_0->arr[j].field_1A_0 == 2) + else if (structPtr->field_0->arr[j].groupScheduledAnim == UNION_ROOM_SPAWN_OUT) { + // Person dropped. Wait 15 seconds, then remove them. structPtr->field_0->arr[j].field_18++; if (structPtr->field_0->arr[j].field_18 >= 900) { - sub_811A5E4(&structPtr->field_0->arr[j], 1); + BlankUnkStruct_x20Array(&structPtr->field_0->arr[j], 1); } } } } - for (i = 0; i < 4; i++) + + // Update the players list + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (sub_811A798(&structPtr->field_0->arr[0], &structPtr->field_4->arr[i], 8) != 0xFF) + if (Appendx1Ctox20(&structPtr->field_0->arr[0], &structPtr->field_4->arr[i], UROOM_MAX_GROUP_COUNT) != 0xFF) r7 = 1; } return r7; } -static void sub_8119D34(u8 taskId) +static void Task_SearchForChildOrParent(u8 taskId) { s32 i, j; - struct UnkStruct_Shared sp0; + struct UnionGnameUnamePair gname_uname; struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data; - bool8 r4; + bool8 parent_child; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - r4 = sub_80FCC3C(&sp0.gname, sp0.playerName, i); - if (!sub_8116F28(sp0.gname.unk_0a_0, gTasks[taskId].data[4])) + parent_child = LinkRfu_GetNameIfCompatible(&gname_uname.gname, gname_uname.uname, i); + if (!IsPartnerActivityAcceptable(gname_uname.gname.activity, gTasks[taskId].data[4])) { - sp0 = gUnknown_8457034; + gname_uname = sUnionGnameUnamePair_Dummy; } - if (sp0.gname.unk_00.unk_00_0 == 1) + if (gname_uname.gname.unk_00.language == LANGUAGE_JAPANESE) { - sp0 = gUnknown_8457034; + gname_uname = sUnionGnameUnamePair_Dummy; } - if (!r4) + if (parent_child == MODE_CHILD) { for (j = 0; j < i; j++) { - if (!sub_811A694(&ptr[1]->arr[j].unk0, &sp0)) + if (!AreGnameUnameDifferent(&ptr[1]->arr[j].gname_uname, &gname_uname)) { - sp0 = gUnknown_8457034; + gname_uname = sUnionGnameUnamePair_Dummy; } } - ptr[1]->arr[i].unk0 = sp0; - ptr[1]->arr[i].unk18 = sub_811A694(&ptr[1]->arr[i].unk0, &gUnknown_8457034); + ptr[1]->arr[i].gname_uname = gname_uname; + ptr[1]->arr[i].active = AreGnameUnameDifferent(&ptr[1]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy); } else { - ptr[0]->arr[i].unk0 = sp0; - ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034); + ptr[0]->arr[i].gname_uname = gname_uname; + ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy); } } } -static u8 sub_8119E84(struct UnkStruct_Main4 * a0, struct UnkStruct_Main4 * a1, u32 a2) +static u8 CreateTask_SearchForChildOrParent(struct UnkStruct_Main4 * main4_parent, struct UnkStruct_Main4 * main4_child, u32 linkGroup) { - u8 taskId = CreateTask(sub_8119D34, 0); + u8 taskId = CreateTask(Task_SearchForChildOrParent, 0); struct UnkStruct_Main4 ** data = (void *)gTasks[taskId].data; - data[0] = a0; - data[1] = a1; - gTasks[taskId].data[4] = a2; + data[0] = main4_parent; + data[1] = main4_child; + gTasks[taskId].data[4] = linkGroup; return taskId; } -static void sub_8119EB8(u8 taskId) +static void Task_ListenForPartnersWithCompatibleSerialNos(u8 taskId) { s32 i, j; struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - sub_80FCC3C(&ptr[0]->arr[i].unk0.gname, ptr[0]->arr[i].unk0.playerName, i); - if (!sub_8116F28(ptr[0]->arr[i].unk0.gname.unk_0a_0, gTasks[taskId].data[2])) + LinkRfu_GetNameIfCompatible(&ptr[0]->arr[i].gname_uname.gname, ptr[0]->arr[i].gname_uname.uname, i); + if (!IsPartnerActivityAcceptable(ptr[0]->arr[i].gname_uname.gname.activity, gTasks[taskId].data[2])) { - ptr[0]->arr[i].unk0 = gUnknown_8457034; + ptr[0]->arr[i].gname_uname = sUnionGnameUnamePair_Dummy; } for (j = 0; j < i; j++) { - if (!sub_811A694(&ptr[0]->arr[j].unk0, &ptr[0]->arr[i].unk0)) + if (!AreGnameUnameDifferent(&ptr[0]->arr[j].gname_uname, &ptr[0]->arr[i].gname_uname)) { - ptr[0]->arr[i].unk0 = gUnknown_8457034; + ptr[0]->arr[i].gname_uname = sUnionGnameUnamePair_Dummy; } } - ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034); + ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy); } } -static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1) +static bool32 GetGnameWonderFlagByLinkGroup(struct GFtgtGname * gname, s16 linkGroup) { - if (arg1 == 7) + if (linkGroup == LINK_GROUP_WONDER_CARD) { - if (!arg0->unk_00.unk_00_5) + if (!gname->unk_00.hasCard) { return FALSE; } @@ -3590,9 +3726,9 @@ static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1) return TRUE; } } - else if (arg1 == 8) + else if (linkGroup == LINK_GROUP_WONDER_NEWS) { - if (!arg0->unk_00.unk_00_4) + if (!gname->unk_00.hasNews) { return FALSE; } @@ -3607,40 +3743,40 @@ static bool32 sub_8119FB0(struct GFtgtGname * arg0, s16 arg1) } } -static void sub_8119FD8(u8 taskId) +static void Task_ListenForPartnersWithSerial7F7D(u8 taskId) { s32 i; struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (sub_80FCCF4(&ptr[0]->arr[i].unk0.gname, ptr[0]->arr[i].unk0.playerName, i)) + if (LinkRfu_GetNameIfSerial7F7D(&ptr[0]->arr[i].gname_uname.gname, ptr[0]->arr[i].gname_uname.uname, i)) { - sub_8119FB0(&ptr[0]->arr[i].unk0.gname, gTasks[taskId].data[2]); + GetGnameWonderFlagByLinkGroup(&ptr[0]->arr[i].gname_uname.gname, gTasks[taskId].data[2]); } - ptr[0]->arr[i].unk18 = sub_811A694(&ptr[0]->arr[i].unk0, &gUnknown_8457034); + ptr[0]->arr[i].active = AreGnameUnameDifferent(&ptr[0]->arr[i].gname_uname, &sUnionGnameUnamePair_Dummy); } } -static u8 sub_811A054(struct UnkStruct_Main4 * a0, u32 a1) +static u8 CreateTask_ListenForPartnersWithCompatibleSerialNos(struct UnkStruct_Main4 * main4, u32 linkGroup) { - u8 taskId = CreateTask(sub_8119EB8, 0); + u8 taskId = CreateTask(Task_ListenForPartnersWithCompatibleSerialNos, 0); struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data; - ptr[0] = a0; - gTasks[taskId].data[2] = a1; + ptr[0] = main4; + gTasks[taskId].data[2] = linkGroup; return taskId; } -static u8 sub_811A084(struct UnkStruct_Main4 * a0, u32 a1) +static u8 CreateTask_ListenForPartnersWithSerial7F7D(struct UnkStruct_Main4 * main4, u32 linkGroup) { - u8 taskId = CreateTask(sub_8119FD8, 0); + u8 taskId = CreateTask(Task_ListenForPartnersWithSerial7F7D, 0); struct UnkStruct_Main4 ** ptr = (void*) gTasks[taskId].data; - ptr[0] = a0; - gTasks[taskId].data[2] = a1; + ptr[0] = main4; + gTasks[taskId].data[2] = linkGroup; return taskId; } -static bool32 sub_811A0B4(const u8 *src) +static bool32 UR_PrintFieldMessage(const u8 *src) { LoadStdWindowFrameGfx(); DrawDialogueFrame(0, 1); @@ -3649,7 +3785,7 @@ static bool32 sub_811A0B4(const u8 *src) return FALSE; } -static bool32 sub_811A0E0(void) +static bool32 UR_RunTextPrinters_CheckPrinter0Active(void) { if (!RunTextPrinters_CheckPrinter0Active()) { @@ -3683,31 +3819,31 @@ static bool8 PrintOnTextbox(u8 *textState, const u8 *str) return FALSE; } -static s8 sub_811A14C(u8 *arg0, bool32 arg1) +static s8 UnionRoomHandleYesNo(u8 *state_p, bool32 no_draw) { s8 r1; - switch (*arg0) + switch (*state_p) { case 0: - if (arg1) + if (no_draw) { return -3; } DisplayYesNoMenuDefaultYes(); - (*arg0)++; + (*state_p)++; break; case 1: - if (arg1) + if (no_draw) { DestroyYesNoMenu(); - *arg0 = 0; + *state_p = 0; return -3; } r1 = Menu_ProcessInputNoWrapClearOnChoose(); if (r1 == -1 || r1 == 0 || r1 == 1) { - *arg0 = 0; + *state_p = 0; return r1; } break; @@ -3715,54 +3851,54 @@ static s8 sub_811A14C(u8 *arg0, bool32 arg1) return -2; } -static u8 sub_811A1AC(const struct WindowTemplate * template) +static u8 CreateTradeBoardWindow(const struct WindowTemplate * template) { u8 windowId = AddWindow(template); DrawStdWindowFrame(windowId, FALSE); FillWindowPixelBuffer(windowId, PIXEL_FILL(15)); - sub_811A444(windowId, 0, gUnknown_8459378, 8, 1, 6); + UR_AddTextPrinterParameterized(windowId, 0, gUnknown_8459378, 8, 1, UR_COLOR_DN5_DN6_LTB); PutWindowTilemap(windowId); CopyWindowToVram(windowId, 2); return windowId; } -static void sub_811A1FC(u8 windowId) +static void DeleteTradeBoardWindow(u8 windowId) { ClearStdWindowAndFrame(windowId, TRUE); RemoveWindow(windowId); } -static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate) +static s32 ListMenuHandler_AllItemsAvailable(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate) { - s32 r1, r8; + s32 input; - switch (*arg0) + switch (*state_p) { case 0: - *arg1 = AddWindow(winTemplate); - DrawStdWindowFrame(*arg1, FALSE); + *win_id_p = AddWindow(winTemplate); + DrawStdWindowFrame(*win_id_p, FALSE); gMultiuseListMenuTemplate = *menuTemplate; - gMultiuseListMenuTemplate.windowId = *arg1; - *arg2 = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); - CopyWindowToVram(*arg1, TRUE); - (*arg0)++; + gMultiuseListMenuTemplate.windowId = *win_id_p; + *list_menu_id_p = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); + CopyWindowToVram(*win_id_p, TRUE); + (*state_p)++; break; case 1: - r8 = ListMenu_ProcessInput(*arg2); + input = ListMenu_ProcessInput(*list_menu_id_p); if (JOY_NEW(A_BUTTON)) { - DestroyListMenuTask(*arg2, NULL, NULL); - ClearStdWindowAndFrame(*arg1, TRUE); - RemoveWindow(*arg1); - *arg0 = 0; - return r8; + DestroyListMenuTask(*list_menu_id_p, NULL, NULL); + ClearStdWindowAndFrame(*win_id_p, TRUE); + RemoveWindow(*win_id_p); + *state_p = 0; + return input; } else if (JOY_NEW(B_BUTTON)) { - DestroyListMenuTask(*arg2, NULL, NULL); - ClearStdWindowAndFrame(*arg1, TRUE); - RemoveWindow(*arg1); - *arg0 = 0; + DestroyListMenuTask(*list_menu_id_p, NULL, NULL); + ClearStdWindowAndFrame(*win_id_p, TRUE); + RemoveWindow(*win_id_p); + *state_p = 0; return -2; } break; @@ -3771,46 +3907,46 @@ static s32 sub_811A218(u8 *arg0, u8 *arg1, u8 *arg2, const struct WindowTemplate return -1; } -static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * arg6) +static s32 TradeBoardMenuHandler(u8 *state_p, u8 *win_id_p, u8 *list_menu_id_p, u8 *trade_board_win_id_p, const struct WindowTemplate * winTemplate, const struct ListMenuTemplate * menuTemplate, struct UnkStruct_Main0 * traders) { s32 input; s32 r4; - switch (*arg0) + switch (*state_p) { case 0: - *arg3 = sub_811A1AC(&gUnknown_8456F1C); - *arg1 = AddWindow(winTemplate); - DrawStdWindowFrame(*arg1, FALSE); + *trade_board_win_id_p = CreateTradeBoardWindow(&sTradeBoardWindowTemplate); + *win_id_p = AddWindow(winTemplate); + DrawStdWindowFrame(*win_id_p, FALSE); gMultiuseListMenuTemplate = *menuTemplate; - gMultiuseListMenuTemplate.windowId = *arg1; - *arg2 = ListMenuInit(&gMultiuseListMenuTemplate, 0, 1); - CopyWindowToVram(*arg1, TRUE); - (*arg0)++; + gMultiuseListMenuTemplate.windowId = *win_id_p; + *list_menu_id_p = ListMenuInit(&gMultiuseListMenuTemplate, 0, 1); + CopyWindowToVram(*win_id_p, TRUE); + (*state_p)++; break; case 1: - input = ListMenu_ProcessInput(*arg2); + input = ListMenu_ProcessInput(*list_menu_id_p); if (JOY_NEW(A_BUTTON | B_BUTTON)) { - if (input == 8 || JOY_NEW(B_BUTTON)) + if (input == UROOM_MAX_GROUP_COUNT || JOY_NEW(B_BUTTON)) { - DestroyListMenuTask(*arg2, NULL, NULL); - ClearStdWindowAndFrame(*arg1, TRUE); - RemoveWindow(*arg1); - sub_811A1FC(*arg3); - *arg0 = 0; + DestroyListMenuTask(*list_menu_id_p, NULL, NULL); + ClearStdWindowAndFrame(*win_id_p, TRUE); + RemoveWindow(*win_id_p); + DeleteTradeBoardWindow(*trade_board_win_id_p); + *state_p = 0; return -2; } else { - r4 = sub_811AD7C(arg6->arr, input); + r4 = GetIndexOfNthTradeBoardOffer(traders->arr, input); if (r4 >= 0) { - DestroyListMenuTask(*arg2, NULL, NULL); - ClearStdWindowAndFrame(*arg1, TRUE); - RemoveWindow(*arg1); - sub_811A1FC(*arg3); - *arg0 = 0; + DestroyListMenuTask(*list_menu_id_p, NULL, NULL); + ClearStdWindowAndFrame(*win_id_p, TRUE); + RemoveWindow(*win_id_p); + DeleteTradeBoardWindow(*trade_board_win_id_p); + *state_p = 0; return r4; } else @@ -3825,20 +3961,20 @@ static s32 sub_811A2EC(u8 *arg0, u8 *arg1, u8 *arg2, u8 *arg3, const struct Wind return -1; } -static void sub_811A3F8(void) +static void UR_BlankBg0(void) { FillBgTilemapBufferRect(0, 0, 0, 0, 32, 32, 0); CopyBgTilemapBufferToVram(0); } -static void sub_811A41C(void) +static void JoinGroup_BlankBg0AndEnableScriptContexts(void) { FillBgTilemapBufferRect(0, 0, 0, 0, 32, 32, 0); CopyBgTilemapBufferToVram(0); EnableBothScriptContexts(); } -static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx) +static void UR_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 colorIdx) { struct TextPrinterTemplate printerTemplate; @@ -3854,100 +3990,100 @@ static void sub_811A444(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 co gTextFlags.useAlternateDownArrow = FALSE; switch (colorIdx) { - case 0: + case UR_COLOR_DKE_WHT_LTE: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 2; - printerTemplate.bgColor = 1; - printerTemplate.shadowColor = 3; + printerTemplate.fgColor = TEXT_COLOR_DARK_GREY; + printerTemplate.bgColor = TEXT_COLOR_WHITE; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY; break; - case 1: + case UR_COLOR_RED_WHT_LTR: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 4; - printerTemplate.bgColor = 1; - printerTemplate.shadowColor = 5; + printerTemplate.fgColor = TEXT_COLOR_RED; + printerTemplate.bgColor = TEXT_COLOR_WHITE; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_RED; break; - case 2: + case UR_COLOR_GRN_WHT_LTG: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 6; - printerTemplate.bgColor = 1; - printerTemplate.shadowColor = 7; + printerTemplate.fgColor = TEXT_COLOR_GREEN; + printerTemplate.bgColor = TEXT_COLOR_WHITE; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREEN; break; - case 3: + case UR_COLOR_WHT_WHT_LTE: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 1; - printerTemplate.bgColor = 1; - printerTemplate.shadowColor = 3; + printerTemplate.fgColor = TEXT_COLOR_WHITE; + printerTemplate.bgColor = TEXT_COLOR_WHITE; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY; break; - case 4: + case UR_COLOR_WHT_DKE_LTE: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 1; - printerTemplate.bgColor = 2; - printerTemplate.shadowColor = 3; + printerTemplate.fgColor = TEXT_COLOR_WHITE; + printerTemplate.bgColor = TEXT_COLOR_DARK_GREY; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_GREY; break; - case 5: + case UR_COLOR_GRN_DN6_LTB: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 7; - printerTemplate.bgColor = 15; - printerTemplate.shadowColor = 9; + printerTemplate.fgColor = TEXT_COLOR_LIGHT_GREEN; + printerTemplate.bgColor = TEXT_DYNAMIC_COLOR_6; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_BLUE; break; - case 6: + case UR_COLOR_DN5_DN6_LTB: printerTemplate.letterSpacing = 0; printerTemplate.lineSpacing = 0; - printerTemplate.fgColor = 14; - printerTemplate.bgColor = 15; - printerTemplate.shadowColor = 9; + printerTemplate.fgColor = TEXT_DYNAMIC_COLOR_5; + printerTemplate.bgColor = TEXT_DYNAMIC_COLOR_6; + printerTemplate.shadowColor = TEXT_COLOR_LIGHT_BLUE; break; } AddTextPrinter(&printerTemplate, 0xFF, NULL); } -static void sub_811A5E4(struct UnkStruct_x20 * arg0, u8 count) +static void BlankUnkStruct_x20Array(struct UnkStruct_x20 * x20arr, u8 count) { s32 i; for (i = 0; i < count; i++) { - arg0[i].unk = gUnknown_8457034; - arg0[i].field_18 = 0xFF; - arg0[i].field_1A_0 = 0; - arg0[i].field_1A_1 = 0; - arg0[i].field_1B = 0; + x20arr[i].gname_uname = sUnionGnameUnamePair_Dummy; + x20arr[i].field_18 = 0xFF; + x20arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; + x20arr[i].field_1A_1 = FALSE; + x20arr[i].field_1B = 0; } } -static void sub_811A650(struct UnkStruct_x1C * arg0, u8 count) +static void BlankUnkStruct_x1CArray(struct UnkStruct_x1C * x1Carr, u8 count) { s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - arg0[i].unk0 = gUnknown_8457034; - arg0[i].unk18 = 0; + x1Carr[i].gname_uname = sUnionGnameUnamePair_Dummy; + x1Carr[i].active = FALSE; } } -static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_Shared * arg1) +static bool8 AreGnameUnameDifferent(struct UnionGnameUnamePair * left, const struct UnionGnameUnamePair * right) { s32 i; for (i = 0; i < 2; i++) { - if (arg0->gname.unk_00.playerTrainerId[i] != arg1->gname.unk_00.playerTrainerId[i]) + if (left->gname.unk_00.playerTrainerId[i] != right->gname.unk_00.playerTrainerId[i]) { return TRUE; } } - for (i = 0; i < 8; i++) + for (i = 0; i < RFU_USER_NAME_LENGTH; i++) { - if (arg0->playerName[i] != arg1->playerName[i]) + if (left->uname[i] != right->uname[i]) { return TRUE; } @@ -3956,34 +4092,34 @@ static bool8 sub_811A694(struct UnkStruct_Shared * arg0, const struct UnkStruct_ return FALSE; } -static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Shared * arg1) +static bool32 AreUnionRoomPlayerGnamesDifferent(struct UnionGnameUnamePair * left, struct UnionGnameUnamePair * right) { s32 i; - if (arg0->gname.unk_0a_0 != arg1->gname.unk_0a_0) + if (left->gname.activity != right->gname.activity) { return TRUE; } - if (arg0->gname.unk_0a_7 != arg1->gname.unk_0a_7) + if (left->gname.started != right->gname.started) { return TRUE; } - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (arg0->gname.unk_04[i] != arg1->gname.unk_04[i]) + if (left->gname.child_sprite_gender[i] != right->gname.child_sprite_gender[i]) { return TRUE; } } - if (arg0->gname.species != arg1->gname.species) + if (left->gname.species != right->gname.species) { return TRUE; } - if (arg0->gname.type != arg1->gname.type) + if (left->gname.type != right->gname.type) { return TRUE; } @@ -3991,38 +4127,38 @@ static bool32 sub_811A6DC(struct UnkStruct_Shared * arg0, struct UnkStruct_Share return FALSE; } -static u32 sub_811A748(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1) +static u32 Findx20Inx1CArray(struct UnkStruct_x20 * x20, struct UnkStruct_x1C * x1Carr) { u8 result = 0xFF; s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (arg1[i].unk18 && !sub_811A694(&arg0->unk, &arg1[i].unk0)) + if (x1Carr[i].active && !AreGnameUnameDifferent(&x20->gname_uname, &x1Carr[i].gname_uname)) { result = i; - arg1[i].unk18 = FALSE; + x1Carr[i].active = FALSE; } } return result; } -static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1, u8 arg2) +static u8 Appendx1Ctox20(struct UnkStruct_x20 * x20arr, struct UnkStruct_x1C * x1C, u8 count) { s32 i; - if (arg1->unk18) + if (x1C->active) { - for (i = 0; i < arg2; i++) + for (i = 0; i < count; i++) { - if (arg0[i].field_1A_0 == 0) + if (x20arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_NONE) { - arg0[i].unk = arg1->unk0; - arg0[i].field_18 = 0; - arg0[i].field_1A_0 = 1; - arg0[i].field_1B = 64; - arg1->unk18 = FALSE; + x20arr[i].gname_uname = x1C->gname_uname; + x20arr[i].field_18 = 0; + x20arr[i].groupScheduledAnim = UNION_ROOM_SPAWN_IN; + x20arr[i].field_1B = 0x40; + x1C->active = FALSE; return i; } } @@ -4031,47 +4167,47 @@ static u8 sub_811A798(struct UnkStruct_x20 * arg0, struct UnkStruct_x1C * arg1, return 0xFF; } -static void sub_811A81C(u8 arg0, u8 arg1, u8 arg2, struct UnkStruct_x20 * arg3, u8 arg4, u8 id) +static void PrintUnionRoomGroupOnWindow(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id) { - u8 r2; - u8 sp0[6]; - u8 sp10[30]; + u8 activity; + u8 id_str[6]; + u8 uname[30]; ConvertIntToDecimalStringN(gStringVar4, id + 1, STR_CONV_MODE_LEADING_ZEROS, 2); StringAppend(gStringVar4, gUnknown_84571B0); - sub_811A444(arg0, 0, gStringVar4, arg1, arg2, 0); - arg1 += 18; - r2 = arg3->unk.gname.unk_0a_0; - if (arg3->field_1A_0 == 1 && !(r2 & 0x40)) + UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, UR_COLOR_DKE_WHT_LTE); + x += 18; + activity = group->gname_uname.gname.activity; + if (group->groupScheduledAnim == UNION_ROOM_SPAWN_IN && !(activity & IN_UNION_ROOM)) { - IntlConvPartnerUname(sp10, *arg3); - sub_811A444(arg0, 2, sp10, arg1, arg2, arg4); - ConvertIntToDecimalStringN(sp0, arg3->unk.gname.unk_00.playerTrainerId[0] | (arg3->unk.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); + IntlConvPartnerUname(uname, *group); + UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx); + ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); StringCopy(gStringVar4, gUnknown_84571B4); - StringAppend(gStringVar4, sp0); - arg1 += 77; - sub_811A444(arg0, 0, gStringVar4, arg1, arg2, arg4); + StringAppend(gStringVar4, id_str); + x += 77; + UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, colorIdx); } } -static void sub_811A910(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * arg3, u8 arg4, u8 id) +static void PrintGroupMemberCandidateOnWindowWithColor(u8 windowId, u8 x, u8 y, struct UnkStruct_x20 * group, u8 colorIdx, u8 id) { - u8 sp0[6]; - u8 sp10[30]; + u8 id_str[6]; + u8 uname[30]; - if (arg3->field_1A_0 == 1) + if (group->groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - IntlConvPartnerUname(sp10, *arg3); - sub_811A444(windowId, 2, sp10, x, y, arg4); - ConvertIntToDecimalStringN(sp0, arg3->unk.gname.unk_00.playerTrainerId[0] | (arg3->unk.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); + IntlConvPartnerUname(uname, *group); + UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx); + ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); StringCopy(gStringVar4, gUnknown_84571B4); - StringAppend(gStringVar4, sp0); + StringAppend(gStringVar4, id_str); x += 71; - sub_811A444(windowId, 0, gStringVar4, x, y, arg4); + UR_AddTextPrinterParameterized(windowId, 0, gStringVar4, x, y, colorIdx); } } -static bool32 sub_811A9B8(void) +static bool32 PlayerIsTalkingToUnionRoomAide(void) { s16 x, y; GetXYCoordsOneStepInFrontOfPlayer(&x, &y); @@ -4091,72 +4227,77 @@ static bool32 sub_811A9B8(void) return FALSE; } -static u32 sub_811A9FC(s32 arg0) +static u32 GetResponseIdx_InviteToURoomActivity(s32 activity) { - switch (arg0) + switch (activity) { - case 5: + case ACTIVITY_CHAT: return 1; - case 4: + case ACTIVITY_TRADE: return 2; - case 8: + case ACTIVITY_CARD: return 3; - case 3: + case ACTIVITY_MLTBATTLE: default: return 0; } } -static u32 sub_811AA24(struct UnkStruct_x20 * arg0) +static u32 ConvPartnerUnameAndGetWhetherMetAlready(struct UnkStruct_x20 * x20) { u8 sp0[30]; - IntlConvPartnerUname(sp0, *arg0); - return PlayerHasMetTrainerBefore(ReadAsU16(arg0->unk.gname.unk_00.playerTrainerId), sp0); + IntlConvPartnerUname(sp0, *x20); + return PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), sp0); } -static s32 sub_811AA5C(struct UnkStruct_Main0 * arg0, u8 arg1, u8 arg2, u32 playerGender) +static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, u8 overrideGender, u8 playerIdx, u32 playerGender) { - bool32 r2; + bool32 metBefore; - struct UnkStruct_x20 * r5 = &arg0->arr[arg2]; + struct UnkStruct_x20 * x20 = &main0->arr[playerIdx]; - if (!r5->unk.gname.unk_0a_7 && arg1 == 0) + if (!x20->gname_uname.gname.started && overrideGender == 0) { - IntlConvPartnerUname(gStringVar1, *r5); - r2 = PlayerHasMetTrainerBefore(ReadAsU16(r5->unk.gname.unk_00.playerTrainerId), gStringVar1); - if (r5->unk.gname.unk_0a_0 == 0x45) + IntlConvPartnerUname(gStringVar1, *x20); + metBefore = PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), gStringVar1); + if (x20->gname_uname.gname.activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { - StringExpandPlaceholders(gStringVar4, gUnknown_8457F80[r2][playerGender]); + StringExpandPlaceholders(gStringVar4, gUnknown_8457F80[metBefore][playerGender]); return 2; } else { - sub_811A0B4(gUnknown_8457A34[r2]); + UR_PrintFieldMessage(gURText_PleaseWaitMsgs[metBefore]); return 1; } } else { - IntlConvPartnerUname(gStringVar1, *r5); - if (arg1 != 0) + IntlConvPartnerUname(gStringVar1, *x20); + if (overrideGender != 0) { - playerGender = (r5->unk.gname.unk_00.playerTrainerId[arg1 + 1] >> 3) & 1; + playerGender = (x20->gname_uname.gname.unk_00.playerTrainerId[overrideGender + 1] >> 3) & 1; } - switch (r5->unk.gname.unk_0a_0 & 0x3F) + switch (x20->gname_uname.gname.activity & 0x3F) { - case 1: + case ACTIVITY_BATTLE: + // Battling StringExpandPlaceholders(gStringVar4, gUnknown_8458758[playerGender][Random() % 4]); break; - case 4: + case ACTIVITY_TRADE: + // Trading StringExpandPlaceholders(gStringVar4, gUnknown_8458A78[playerGender][Random() % 2]); break; - case 5: + case ACTIVITY_CHAT: + // Chatting StringExpandPlaceholders(gStringVar4, gUnknown_84588BC[playerGender][Random() % 4]); break; - case 8: + case ACTIVITY_CARD: + // Sharing cards StringExpandPlaceholders(gStringVar4, gUnknown_84589AC[playerGender][Random() % 2]); break; default: + // Unknown StringExpandPlaceholders(gStringVar4, gUnknown_8457F90); break; } @@ -4169,73 +4310,73 @@ static void nullsub_92(u8 windowId, s32 itemId, u8 y) } -static void sub_811ABE4(u8 windowId, u8 y, struct GFtgtGname * gname, const u8 * uname, u8 colorIdx) +static void TradeBoardPrintItemInfo(u8 windowId, u8 y, struct GFtgtGname * gname, const u8 * uname, u8 colorIdx) { u8 level_t[4]; u16 species = gname->species; u8 type = gname->type; u8 level = gname->level; - sub_811A444(windowId, 2, uname, 8, y, colorIdx); + UR_AddTextPrinterParameterized(windowId, 2, uname, 8, y, colorIdx); if (species == SPECIES_EGG) { - sub_811A444(windowId, 2, gUnknown_8458FBC, 0x44, y, colorIdx); + UR_AddTextPrinterParameterized(windowId, 2, gText_EggTrade, 0x44, y, colorIdx); } else { BlitMoveInfoIcon(windowId, type + 1, 0x44, y); - sub_811A444(windowId, 2, gSpeciesNames[species], 0x76, y, colorIdx); + UR_AddTextPrinterParameterized(windowId, 2, gSpeciesNames[species], 0x76, y, colorIdx); ConvertIntToDecimalStringN(level_t, level, STR_CONV_MODE_LEFT_ALIGN, 3); - sub_811A444(windowId, 2, level_t, GetStringRightAlignXOffset(2, level_t, 218), y, colorIdx); + UR_AddTextPrinterParameterized(windowId, 2, level_t, GetStringRightAlignXOffset(2, level_t, 218), y, colorIdx); } } -static void sub_811ACA4(u8 windowId, s32 itemId, u8 y) +static void TradeBoardListMenuItemPrintFunc(u8 windowId, s32 itemId, u8 y) { struct UnkStruct_Leader * leader = sUnionRoomMain.leader; struct GFtgtGname * rfu; s32 i, j; - u8 uname[8]; + u8 uname[RFU_USER_NAME_LENGTH]; - if (itemId == -3 && y == gUnknown_8456F7C.upText_Y) + if (itemId == -3 && y == sTradeBoardListMenuTemplate.upText_Y) { - rfu = sub_80F9800(); + rfu = GetHostRFUtgtGname(); if (rfu->species != SPECIES_NONE) { - sub_811ABE4(windowId, y, rfu, gSaveBlock2Ptr->playerName, 5); + TradeBoardPrintItemInfo(windowId, y, rfu, gSaveBlock2Ptr->playerName, 5); } } else { j = 0; - for (i = 0; i < 8; i++) + for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++) { - if (leader->field_0->arr[i].field_1A_0 == 1 && leader->field_0->arr[i].unk.gname.species != SPECIES_NONE) + if (leader->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && leader->field_0->arr[i].gname_uname.gname.species != SPECIES_NONE) { j++; } if (j == itemId + 1) { IntlConvPartnerUname(uname, leader->field_0->arr[i]); - sub_811ABE4(windowId, y, &leader->field_0->arr[i].unk.gname, uname, 6); + TradeBoardPrintItemInfo(windowId, y, &leader->field_0->arr[i].gname_uname.gname, uname, 6); break; } } } } -static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1) +static s32 GetIndexOfNthTradeBoardOffer(struct UnkStruct_x20 * x20, s32 n) { s32 i; s32 j = 0; - for (i = 0; i < 8; i++) + for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++) { - if (arg[i].field_1A_0 == 1 && arg[i].unk.gname.species != SPECIES_NONE) + if (x20[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && x20[i].gname_uname.gname.species != SPECIES_NONE) { j++; } - if (j == arg1 + 1) + if (j == n + 1) { return i; } @@ -4244,12 +4385,12 @@ static s32 sub_811AD7C(struct UnkStruct_x20 * arg, s32 arg1) return -1; } -static s32 GetUnionRoomPlayerGender(s32 arg1, struct UnkStruct_Main0 * arg0) +static s32 GetUnionRoomPlayerGender(s32 playerIdx, struct UnkStruct_Main0 * main0) { - return arg0->arr[arg1].unk.gname.playerGender; + return main0->arr[playerIdx].gname_uname.gname.playerGender; } -static s32 sub_811ADD0(u32 type, u32 species) +static s32 IsRequestedTypeAndSpeciesInPlayerParty(u32 type, u32 species) { s32 i; @@ -4260,10 +4401,10 @@ static s32 sub_811ADD0(u32 type, u32 species) species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2); if (species == SPECIES_EGG) { - return 0; + return UR_TRADE_MATCH; } } - return 2; + return UR_TRADE_NOEGG; } else { @@ -4272,77 +4413,77 @@ static s32 sub_811ADD0(u32 type, u32 species) species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2); if (gBaseStats[species].type1 == type || gBaseStats[species].type2 == type) { - return 0; + return UR_TRADE_MATCH; } } - return 1; + return UR_TRADE_NOTYPE; } } -static void sub_811AE68(u8 *dst, s32 arg1, u32 playerGender) +static void GetURoomActivityRejectMsg(u8 *dst, s32 activity, u32 playerGender) { - switch (arg1) + switch (activity) { - case 0x41: + case ACTIVITY_BATTLE | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8458314[playerGender]); break; - case 0x45: + case ACTIVITY_CHAT | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_84585E8[playerGender]); break; - case 0x44: + case ACTIVITY_TRADE | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8458F9C); break; - case 0x48: + case ACTIVITY_CARD | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_84583B4[playerGender]); break; } } -static void sub_811AECC(u8 *dst, u8 arg1) +static void GetURoomActivityStartMsg(u8 *dst, u8 activity) { u8 mpId = GetMultiplayerId(); u8 gender = gLinkPlayers[mpId ^ 1].gender; - switch (arg1) + switch (activity) { - case 0x41: + case ACTIVITY_BATTLE | IN_UNION_ROOM: StringCopy(dst, gUnknown_8458230[mpId][gender][0]); break; - case 0x44: + case ACTIVITY_TRADE | IN_UNION_ROOM: StringCopy(dst, gUnknown_8458230[mpId][gender][2]); break; - case 0x45: + case ACTIVITY_CHAT | IN_UNION_ROOM: StringCopy(dst, gUnknown_8458230[mpId][gender][1]); break; } } -static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * arg3) +static s32 GetChatLeaderActionRequestMessage(u8 *dst, u32 gender, u16 *activity_p, struct UnkStruct_URoom * arg3) { s32 result = 0; u16 species = SPECIES_NONE; s32 i; - switch (arg2[0]) + switch (activity_p[0]) { - case 0x41: + case ACTIVITY_BATTLE | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8457CA4); result = 1; break; - case 0x45: + case ACTIVITY_CHAT | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8457CF8); result = 1; break; - case 0x44: - ConvertIntToDecimalStringN(arg3->field_58[0], sUnionRoomTrade.playerLevel, STR_CONV_MODE_LEFT_ALIGN, 3); - StringCopy(arg3->field_58[1], gSpeciesNames[sUnionRoomTrade.playerSpecies]); - for (i = 0; i < 4; i++) + case ACTIVITY_TRADE | IN_UNION_ROOM: + ConvertIntToDecimalStringN(arg3->activityRequestStrbufs[0], sUnionRoomTrade.playerLevel, STR_CONV_MODE_LEFT_ALIGN, 3); + StringCopy(arg3->activityRequestStrbufs[1], gSpeciesNames[sUnionRoomTrade.playerSpecies]); + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuLinkStatus->partner[i].serialNo == 2) + if (gRfuLinkStatus->partner[i].serialNo == 0x0002) { - ConvertIntToDecimalStringN(arg3->field_58[2], arg2[2], STR_CONV_MODE_LEFT_ALIGN, 3); - StringCopy(arg3->field_58[3], gSpeciesNames[arg2[1]]); - species = arg2[1]; + ConvertIntToDecimalStringN(arg3->activityRequestStrbufs[2], activity_p[2], STR_CONV_MODE_LEFT_ALIGN, 3); + StringCopy(arg3->activityRequestStrbufs[3], gSpeciesNames[activity_p[1]]); + species = activity_p[1]; break; } } @@ -4352,19 +4493,20 @@ static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * } else { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - DynamicPlaceholderTextUtil_SetPlaceholderPtr(i, arg3->field_58[i]); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(i, arg3->activityRequestStrbufs[i]); } DynamicPlaceholderTextUtil_ExpandPlaceholders(dst, gUnknown_8457D44); } result = 1; break; - case 0x48: + case ACTIVITY_CARD | IN_UNION_ROOM: StringExpandPlaceholders(dst, gUnknown_8457C48); result = 1; break; - case 0x40: + case IN_UNION_ROOM: + // Chat dropped StringExpandPlaceholders(dst, gUnknown_8457E0C); result = 2; break; @@ -4373,18 +4515,18 @@ static s32 sub_811AF6C(u8 *dst, u32 gender, u16 *arg2, struct UnkStruct_URoom * return result; } -static bool32 sub_811B0A4(struct UnkStruct_URoom * arg0) +static bool32 PollPartnerYesNoResponse(struct UnkStruct_URoom * uroom) { if (gRecvCmds[0][1] != 0) { - if (gRecvCmds[0][1] == 0x51) + if (gRecvCmds[0][1] == (ACTIVITY_ACCEPT | IN_UNION_ROOM)) { - arg0->field_98 = 0x51; + uroom->partnerYesNoResponse = ACTIVITY_ACCEPT | IN_UNION_ROOM; return TRUE; } - else if (gRecvCmds[0][1] == 0x52) + else if (gRecvCmds[0][1] == (ACTIVITY_DECLINE | IN_UNION_ROOM)) { - arg0->field_98 = 0x52; + uroom->partnerYesNoResponse = ACTIVITY_DECLINE | IN_UNION_ROOM; return TRUE; } } @@ -4418,16 +4560,16 @@ static bool32 HasAtLeastTwoMonsOfLevel30OrLower(void) return FALSE; } -static void ResetUnionRoomTrade(struct UnionRoomTrade * arg0) +static void ResetUnionRoomTrade(struct UnionRoomTrade * uroomTrade) { - arg0->field_0 = 0; - arg0->type = 0; - arg0->playerPersonality = 0; - arg0->playerSpecies = 0; - arg0->playerLevel = 0; - arg0->species = 0; - arg0->level = 0; - arg0->personality = 0; + uroomTrade->field_0 = 0; + uroomTrade->type = 0; + uroomTrade->playerPersonality = 0; + uroomTrade->playerSpecies = 0; + uroomTrade->playerLevel = 0; + uroomTrade->species = 0; + uroomTrade->level = 0; + uroomTrade->personality = 0; } void Script_ResetUnionRoomTrade(void) @@ -4494,26 +4636,26 @@ static u32 GetPartyPositionOfRegisteredMon(struct UnionRoomTrade * trade, u8 mul return response; } -static void sub_811B258(bool32 arg0) +static void HandleCancelTrade(bool32 unlockObjs) { - sub_811A3F8(); + UR_BlankBg0(); ScriptContext2_Disable(); - sub_80696F0(); - gUnknown_203B058 = 0; - if (arg0) + UnionRoom_UnlockPlayerAndChatPartner(); + sPlayerCurrActivity = 0; + if (unlockObjs) { - sub_80FAFA0(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); - sub_80FB008(0x40, 0, 0); + RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE); } } -static void sub_811B298(void) +static void UR_EnableScriptContext2AndFreezeObjectEvents(void) { ScriptContext2_Enable(); ScriptFreezeObjectEvents(); } -static u8 sub_811B2A8(s32 linkPlayer) +static u8 GetSinglePartnerSpriteGenderParam(s32 linkPlayer) { u8 retval = 0x80; retval |= gLinkPlayers[linkPlayer].gender << 3; @@ -4521,17 +4663,17 @@ static u8 sub_811B2A8(s32 linkPlayer) return retval; } -static u8 sub_811B2D8(struct UnkStruct_URoom * arg0) +static u8 GetActivePartnerSpriteGenderParam(struct UnkStruct_URoom * uroom) { u8 retVal = 0x80; u8 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (arg0->field_C->arr[i].unk18) + if (uroom->field_C->arr[i].active) { - retVal |= arg0->field_C->arr[i].unk0.gname.playerGender << 3; - retVal |= arg0->field_C->arr[i].unk0.gname.unk_00.playerTrainerId[0] & 7; + retVal |= uroom->field_C->arr[i].gname_uname.gname.playerGender << 3; + retVal |= uroom->field_C->arr[i].gname_uname.gname.unk_00.playerTrainerId[0] & 7; break; } } @@ -4539,7 +4681,7 @@ static u8 sub_811B2D8(struct UnkStruct_URoom * arg0) return retVal; } -static void sub_811B31C(u8 *unused, struct UnkStruct_URoom * arg1, bool8 arg2) +static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uroom, bool8 parent_child) { struct TrainerCard * trainerCard = &gTrainerCards[GetMultiplayerId() ^ 1]; s32 i; @@ -4547,61 +4689,61 @@ static void sub_811B31C(u8 *unused, struct UnkStruct_URoom * arg1, bool8 arg2) DynamicPlaceholderTextUtil_Reset(); - StringCopy(arg1->trainerCardStrbufs[0], gTrainerClassNames[sub_80447F0()]); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, arg1->trainerCardStrbufs[0]); + StringCopy(uroom->trainerCardStrbufs[0], gTrainerClassNames[sub_80447F0()]); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]); DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, trainerCard->playerName); - StringCopy(arg1->field_174, gUnknown_84594B0[trainerCard->stars]); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, arg1->field_174); + StringCopy(uroom->field_174, gUnknown_84594B0[trainerCard->stars]); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->field_174); - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[2], trainerCard->caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, arg1->trainerCardStrbufs[2]); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]); - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[3], trainerCard->playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3); - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[4], trainerCard->playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, arg1->trainerCardStrbufs[3]); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(5, arg1->trainerCardStrbufs[4]); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[3], trainerCard->playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[4], trainerCard->playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, uroom->trainerCardStrbufs[3]); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(5, uroom->trainerCardStrbufs[4]); - DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_84594C4); - StringCopy(gStringVar4, arg1->field_1A4); + DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_84594C4); + StringCopy(gStringVar4, uroom->field_1A4); n = trainerCard->linkBattleWins; if (n > 9999) { n = 9999; } - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[0], n, STR_CONV_MODE_LEFT_ALIGN, 4); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, arg1->trainerCardStrbufs[0]); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[0], n, STR_CONV_MODE_LEFT_ALIGN, 4); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]); n = trainerCard->linkBattleLosses; if (n > 9999) { n = 9999; } - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[1], n, STR_CONV_MODE_LEFT_ALIGN, 4); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, arg1->trainerCardStrbufs[1]); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[1], n, STR_CONV_MODE_LEFT_ALIGN, 4); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->trainerCardStrbufs[1]); - ConvertIntToDecimalStringN(arg1->trainerCardStrbufs[2], trainerCard->pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, arg1->trainerCardStrbufs[2]); + ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]); for (i = 0; i < 4; i++) { - CopyEasyChatWord(arg1->trainerCardStrbufs[i + 3], trainerCard->var_28[i]); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, arg1->trainerCardStrbufs[i + 3]); + CopyEasyChatWord(uroom->trainerCardStrbufs[i + 3], trainerCard->var_28[i]); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, uroom->trainerCardStrbufs[i + 3]); } - DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459504); - StringAppend(gStringVar4, arg1->field_1A4); + DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459504); + StringAppend(gStringVar4, uroom->field_1A4); - if (arg2 == TRUE) + if (parent_child == MODE_PARENT) { - DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459588); - StringAppend(gStringVar4, arg1->field_1A4); + DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459588); + StringAppend(gStringVar4, uroom->field_1A4); } - else if (arg2 == FALSE) + else if (parent_child == MODE_CHILD) { - DynamicPlaceholderTextUtil_ExpandPlaceholders(arg1->field_1A4, gUnknown_8459580[trainerCard->gender]); - StringAppend(gStringVar4, arg1->field_1A4); + DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459580[trainerCard->gender]); + StringAppend(gStringVar4, uroom->field_1A4); } } diff --git a/src/union_room_battle.c b/src/union_room_battle.c index b75cc086d..b4d8af9ce 100644 --- a/src/union_room_battle.c +++ b/src/union_room_battle.c @@ -13,15 +13,16 @@ #include "text_window.h" #include "union_room.h" #include "window.h" +#include "constants/union_room.h" -struct UnkStruct_203B08C +struct UnionRoomBattleWork { - s16 a0; + s16 textState; }; -static EWRAM_DATA struct UnkStruct_203B08C * gUnknown_203B08C = NULL; +static EWRAM_DATA struct UnionRoomBattleWork * sWork = NULL; -static const struct BgTemplate gUnknown_8457194[] = { +static const struct BgTemplate sBgTemplates[] = { { .bg = 0, .charBaseIndex = 3, @@ -29,7 +30,7 @@ static const struct BgTemplate gUnknown_8457194[] = { } }; -static const struct WindowTemplate gUnknown_8457198[] = { +static const struct WindowTemplate sWindowTemplates[] = { { .bg = 0, .tilemapLeft = 2, @@ -43,10 +44,10 @@ static const struct WindowTemplate gUnknown_8457198[] = { static const u8 gUnknown_84571A8[] = {1, 2, 3}; -static void sub_811C04C(void) +static void SetUpPartiesAndStartBattle(void) { s32 i; - sub_81173C0(BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER); + StartUnionRoomBattle(BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER); for (i = 0; i < 2; i++) { gEnemyParty[i] = gPlayerParty[gSelectedOrderFromParty[i] - 1]; @@ -65,7 +66,7 @@ static void sub_811C04C(void) SetMainCallback2(CB2_InitBattle); } -static void sub_811C0E0(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed) +static void UnionRoomBattle_CreateTextPrinter(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed) { s32 letterSpacing = 1; s32 lineSpacing = 1; @@ -73,13 +74,13 @@ static void sub_811C0E0(u8 windowId, const u8 * str, u8 x, u8 y, s32 speed) AddTextPrinterParameterized4(windowId, 3, x, y, letterSpacing, lineSpacing, gUnknown_84571A8, speed, str); } -static bool32 sub_811C150(s16 * state, const u8 * str, s32 speed) +static bool32 UnionRoomBattle_PrintTextOnWindow0(s16 * state, const u8 * str, s32 speed) { switch (*state) { case 0: DrawTextBorderOuter(0, 0x001, 0xD); - sub_811C0E0(0, str, 0, 2, speed); + UnionRoomBattle_CreateTextPrinter(0, str, 0, 2, speed); PutWindowTilemap(0); CopyWindowToVram(0, 3); (*state)++; @@ -95,27 +96,27 @@ static bool32 sub_811C150(s16 * state, const u8 * str, s32 speed) return FALSE; } -static void sub_811C1B4(void) +static void VBlankCB_UnionRoomBattle(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -void sub_811C1C8(void) +void CB2_UnionRoomBattle(void) { switch (gMain.state) { case 0: SetGpuReg(REG_OFFSET_DISPCNT, 0x0000); - gUnknown_203B08C = AllocZeroed(sizeof(struct UnkStruct_203B08C)); + sWork = AllocZeroed(sizeof(struct UnionRoomBattleWork)); ResetSpriteData(); FreeAllSpritePalettes(); ResetTasks(); ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, gUnknown_8457194, 1); + InitBgsFromTemplates(0, sBgTemplates, 1); ResetTempTileDataBuffers(); - if (!InitWindows(gUnknown_8457198)) + if (!InitWindows(sWindowTemplates)) { return; } @@ -126,11 +127,11 @@ void sub_811C1C8(void) FillBgTilemapBufferRect(0, 0, 0, 0, 30, 20, 0xF); TextWindow_SetStdFrame0_WithPal(0, 1, 0xD0); Menu_LoadStdPal(); - SetVBlankCallback(sub_811C1B4); + SetVBlankCallback(VBlankCB_UnionRoomBattle); gMain.state++; break; case 1: - if (sub_811C150(&gUnknown_203B08C->a0, gText_CommStandbyAwaitingOtherPlayer, 0)) + if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_CommStandbyAwaitingOtherPlayer, 0)) { gMain.state++; } @@ -146,11 +147,11 @@ void sub_811C1C8(void) memset(gBlockSendBuffer, 0, 0x20); if (gSelectedOrderFromParty[0] == -gSelectedOrderFromParty[1]) { - gBlockSendBuffer[0] = 0x52; + gBlockSendBuffer[0] = ACTIVITY_DECLINE | 0x40; } else { - gBlockSendBuffer[0] = 0x51; + gBlockSendBuffer[0] = ACTIVITY_ACCEPT | 0x40; } SendBlock(0, gBlockSendBuffer, 0x20); gMain.state++; @@ -159,15 +160,15 @@ void sub_811C1C8(void) case 4: if (GetBlockReceivedStatus() == 3) { - if (gBlockRecvBuffer[0][0] == 0x51 && gBlockRecvBuffer[1][0] == 0x51) + if (gBlockRecvBuffer[0][0] == (ACTIVITY_ACCEPT | 0x40) && gBlockRecvBuffer[1][0] == (ACTIVITY_ACCEPT | 0x40)) { BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); gMain.state = 50; } else { - sub_800AAC0(); - if (gBlockRecvBuffer[GetMultiplayerId()][0] == 0x52) + Link_TryStartSend5FFF(); + if (gBlockRecvBuffer[GetMultiplayerId()][0] == (ACTIVITY_DECLINE | 0x40)) { gMain.state = 6; } @@ -182,14 +183,14 @@ void sub_811C1C8(void) case 50: if (!UpdatePaletteFade()) { - sub_800AB9C(); + PrepareSendLinkCmd2FFE_or_RfuCmd6600(); gMain.state++; } break; case 51: if (IsLinkTaskFinished()) { - SetMainCallback2(sub_811C04C); + SetMainCallback2(SetUpPartiesAndStartBattle); } break; case 6: @@ -199,7 +200,7 @@ void sub_811C1C8(void) } break; case 7: - if (sub_811C150(&gUnknown_203B08C->a0, gText_RefusedBattle, 1)) + if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_RefusedBattle, 1)) { SetMainCallback2(CB2_ReturnToField); } @@ -211,7 +212,7 @@ void sub_811C1C8(void) } break; case 9: - if (sub_811C150(&gUnknown_203B08C->a0, gText_BattleWasRefused, 1)) + if (UnionRoomBattle_PrintTextOnWindow0(&sWork->textState, gText_BattleWasRefused, 1)) { SetMainCallback2(CB2_ReturnToField); } diff --git a/src/union_room_chat.c b/src/union_room_chat.c index 15601c028..167da514a 100644 --- a/src/union_room_chat.c +++ b/src/union_room_chat.c @@ -207,7 +207,7 @@ void EnterUnionRoomChat(void) sWork = Alloc(sizeof(struct UnionRoomChat)); InitChatWork(sWork); gKeyRepeatStartDelay = 20; - sub_812B4AC(); + HelpSystem_DisableToggleWithRButton(); SetVBlankCallback(NULL); SetMainCallback2(CB2_LoadInterface); } @@ -587,7 +587,7 @@ static void ChatEntryRoutine_ExitChat(void) case 5: if (IsLinkTaskFinished() && !GetRfuUnkCE8()) { - sub_800AAC0(); + Link_TryStartSend5FFF(); sWork->exitDelayTimer = 0; sWork->routineState++; } @@ -622,7 +622,7 @@ static void ChatEntryRoutine_Drop(void) case 1: if (!RunDisplaySubtask(0) && IsLinkTaskFinished() && !GetRfuUnkCE8()) { - sub_800AAC0(); + Link_TryStartSend5FFF(); sWork->exitDelayTimer = 0; sWork->routineState++; } @@ -668,7 +668,7 @@ static void ChatEntryRoutine_Disbanded(void) case 2: if (RunDisplaySubtask(0) != TRUE && IsLinkTaskFinished() && !GetRfuUnkCE8()) { - sub_800AAC0(); + Link_TryStartSend5FFF(); sWork->exitDelayTimer = 0; sWork->routineState++; } @@ -893,7 +893,7 @@ static void ChatEntryRoutine_SaveAndExit(void) case 13: if (!gPaletteFade.active) { - sub_812B4B8(); + HelpSystem_EnableToggleWithRButton(); UnionRoomChat_FreeGraphicsWork(); FreeChatWork(); SetMainCallback2(CB2_ReturnToField); @@ -914,7 +914,7 @@ static bool32 TypeChatMessage_HandleDPad(void) { if (JOY_REPT(DPAD_UP)) { - if (sWork->currentRow) + if (sWork->currentRow > 0) sWork->currentRow--; else sWork->currentRow = sKeyboardPageMaxRow[sWork->currentPage]; @@ -938,7 +938,7 @@ static bool32 TypeChatMessage_HandleDPad(void) { if (JOY_REPT(DPAD_LEFT)) { - if (sWork->currentCol) + if (sWork->currentCol > 0) sWork->currentCol--; else sWork->currentCol = 4; diff --git a/src/union_room_message.c b/src/union_room_message.c index 9ca5aa15b..1d26d1968 100644 --- a/src/union_room_message.c +++ b/src/union_room_message.c @@ -1,10 +1,11 @@ #include "global.h" #include "union_room_message.h" #include "mevent_server.h" +#include "constants/union_room.h" -ALIGNED(4) const u8 gUnknown_84571AC[] = _(""); +ALIGNED(4) const u8 gUnionRoomActivity_Blank[] = _(""); ALIGNED(4) const u8 gUnknown_84571B0[] = _(":"); -ALIGNED(4) const u8 gUnknown_84571B4[] = _("{EXTRA 7}"); +ALIGNED(4) const u8 gUnknown_84571B4[] = _("{ID}"); ALIGNED(4) const u8 gUnknown_84571B8[] = _("Please start over from the beginning."); ALIGNED(4) const u8 gUnknown_84571E0[] = _("The WIRELESS COMMUNICATION\nSYSTEM search has been canceled."); ALIGNED(4) const u8 gUnref_845721C[] = _("ともだちからの れんらくを\nまっています"); @@ -124,6 +125,7 @@ const u8 *const gUnknown_8457754[] = { ALIGNED(4) const u8 gUnknown_845777C[] = _("The WIRELESS COMMUNICATION\nSYSTEM link has been established."); ALIGNED(4) const u8 gUnknown_84577BC[] = _("The WIRELESS COMMUNICATION\nSYSTEM link has been dropped…"); + ALIGNED(4) const u8 gUnknown_84577F8[] = _("The link with your friend has been\ndropped…"); ALIGNED(4) const u8 gUnknown_8457824[] = _("{STR_VAR_1} replied, “No…”"); @@ -150,11 +152,12 @@ const u8 *const gUnknown_8457898[] = { ALIGNED(4) const u8 gUnknown_84578A0[] = _("はなしかけています…\nしょうしょう おまちください"); ALIGNED(4) const u8 gUnknown_84578BC[] = _("Awaiting {STR_VAR_1}'s response about\nthe trade…"); + ALIGNED(4) const u8 gUnknown_84578E4[] = _("Communicating{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}."); ALIGNED(4) const u8 gUnknown_8457950[] = _("Communicating with {STR_VAR_1}{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}."); ALIGNED(4) const u8 gUnknown_84579BC[] = _("Please wait a while{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.\n{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}.{PAUSE 15}."); -const u8 *const gUnknown_8457A34[] = { +const u8 *const gURText_PleaseWaitMsgs[] = { gUnknown_84578E4, gUnknown_8457950, gUnknown_84579BC @@ -165,7 +168,7 @@ ALIGNED(4) const u8 gUnknown_8457A70[] = _("Hello!\nWould you like to do somethi ALIGNED(4) const u8 gUnknown_8457A98[] = _("{STR_VAR_1}: Hiya, we meet again!\nWhat are you up for this time?"); ALIGNED(4) const u8 gUnknown_8457AD0[] = _("{STR_VAR_1}: Oh! {PLAYER}, hello!\nWould you like to do something?"); -const u8 *const gUnknown_8457B04[][2] = { +const u8 *const gURText_FriendPromptsForActivity[][2] = { { gUnknown_8457A40, gUnknown_8457A70 @@ -237,6 +240,7 @@ const u8 *const gUnknown_8457F80[][2] = { }; ALIGNED(4) const u8 gUnknown_8457F90[] = _("……\nThe TRAINER appears to be busy…\p"); + ALIGNED(4) const u8 gUnknown_8457FB4[] = _("A battle, huh?\nAll right, just give me some time."); ALIGNED(4) const u8 gUnknown_8457FE8[] = _("You want to chat, huh?\nSure, just wait a little."); ALIGNED(4) const u8 gUnknown_845801C[] = _("Sure thing! As my “Greetings,”\nhere's my TRAINER CARD."); @@ -244,7 +248,7 @@ ALIGNED(4) const u8 gUnknown_8458054[] = _("A battle? Of course, but I need\ntim ALIGNED(4) const u8 gUnknown_8458088[] = _("Did you want to chat?\nOkay, but please wait a moment."); ALIGNED(4) const u8 gUnknown_84580C0[] = _("As my introduction, I'll show you\nmy TRAINER CARD."); -const u8 *const gUnknown_84580F4[][4] = { +const u8 *const gResponseToURoomActivityInviteStringPtrs[][4] = { { gUnknown_8457FB4, gUnknown_8457FE8, @@ -415,7 +419,8 @@ ALIGNED(4) const u8 gUnknown_8458AB8[] = _("Welcome to the TRADING BOARD.\pYou m ALIGNED(4) const u8 gUnknown_8458B44[] = _("This TRADING BOARD is used for\noffering a POKéMON for a trade.\pAll you need to do is register a\nPOKéMON for a trade.\pAnother TRAINER may offer a party\nPOKéMON in return for the trade.\pWe hope you will register POKéMON\nand trade them with many, many\lother TRAINERS.\pWould you like to register one of\nyour POKéMON?"); ALIGNED(4) const u8 gUnref_ThankYouForComing_JP[] = _("こうかんけいじばん の とうろくが\nかんりょう しました\pごりよう ありがとう\nございました！\p"); ALIGNED(4) const u8 gUnref_NoOneRegisteredMon[] = _("けいじばんに だれも ポケモンを\nとうろく していません\p\n"); -ALIGNED(4) const u8 gUnknown_8458CD4[] = _("Please choose the type of POKéMON\nthat you would like in the trade.\n"); + +ALIGNED(4) const u8 gURText_PleaseChooseTypeOfMon[] = _("Please choose the type of POKéMON\nthat you would like in the trade.\n"); ALIGNED(4) const u8 gUnknown_8458D1C[] = _("Which of your party POKéMON will\nyou offer in trade?\p"); ALIGNED(4) const u8 gUnknown_8458D54[] = _("Registration has been canceled.\p"); ALIGNED(4) const u8 gUnknown_8458D78[] = _("Registration has been completed.\p"); @@ -439,9 +444,10 @@ const u8 *const gUnknown_8458F94[] = { }; ALIGNED(4) const u8 gUnknown_8458F9C[] = _("Your trade offer was rejected.\p"); -ALIGNED(4) const u8 gUnknown_8458FBC[] = _("EGG TRADE"); +ALIGNED(4) const u8 gText_EggTrade[] = _("EGG TRADE"); ALIGNED(4) const u8 gUnknown_8458FC8[] = _("{DPAD_UPDOWN}CHOOSE {A_BUTTON}JOIN {B_BUTTON}CANCEL"); ALIGNED(4) const u8 gUnknown_8458FE4[] = _("Please choose a TRAINER."); + ALIGNED(4) const u8 gUnknown_8459000[] = _("Please choose a TRAINER for\na SINGLE BATTLE."); ALIGNED(4) const u8 gUnknown_8459030[] = _("Please choose a TRAINER for\na DOUBLE BATTLE."); ALIGNED(4) const u8 gUnknown_8459060[] = _("Please choose the LEADER\nfor a MULTI BATTLE."); @@ -453,15 +459,15 @@ ALIGNED(4) const u8 gUnknown_8459160[] = _("BERRY CRUSH!\nPlease choose the LEAD ALIGNED(4) const u8 gUnknown_8459188[] = _("DODRIO BERRY-PICKING!\nPlease choose the LEADER."); const u8 *const gUnknown_84591B8[] = { - gUnknown_8459000, - gUnknown_8459030, - gUnknown_8459060, - gUnknown_8459090, - gUnknown_845912C, - gUnknown_8459160, - gUnknown_8459188, - gUnknown_84590BC, - gUnknown_84590F4 + [LINK_GROUP_SINGLE_BATTLE] = gUnknown_8459000, + [LINK_GROUP_DOUBLE_BATTLE] = gUnknown_8459030, + [LINK_GROUP_MULTI_BATTLE] = gUnknown_8459060, + [LINK_GROUP_TRADE] = gUnknown_8459090, + [LINK_GROUP_POKEMON_JUMP] = gUnknown_845912C, + [LINK_GROUP_BERRY_CRUSH] = gUnknown_8459160, + [LINK_GROUP_BERRY_PICKING] = gUnknown_8459188, + [LINK_GROUP_WONDER_CARD] = gUnknown_84590BC, + [LINK_GROUP_WONDER_NEWS] = gUnknown_84590F4 }; ALIGNED(4) const u8 gUnknown_84591DC[] = _("Searching for a WIRELESS\nCOMMUNICATION SYSTEM. Wait..."); @@ -470,6 +476,7 @@ ALIGNED(4) const u8 gUnknown_8459238[] = _("Awaiting {STR_VAR_1}'s response…") ALIGNED(4) const u8 gUnknown_8459250[] = _("{STR_VAR_1} has been asked to register\nyou as a member. Please wait."); ALIGNED(4) const u8 gUnknown_845928C[] = _("Awaiting a response from the\nWIRELESS COMMUNICATION SYSTEM."); ALIGNED(4) const u8 gUnref_PlsWaitLittleWHile[] = _("ほかの さんかしゃが そろうまで\nしょうしょう おまちください"); + ALIGNED(4) const u8 gUnknown_84592E8[] = _("No CARDS appear to be shared \nright now."); ALIGNED(4) const u8 gUnknown_8459314[] = _("No NEWS appears to be shared\nright now."); @@ -482,23 +489,26 @@ ALIGNED(4) const u8 gUnknown_8459344[] = _("BATTLE"); ALIGNED(4) const u8 gUnknown_845934C[] = _("CHAT"); ALIGNED(4) const u8 gUnknown_8459354[] = _("GREETINGS"); ALIGNED(4) const u8 gUnknown_8459360[] = _("EXIT"); + ALIGNED(4) const u8 gUnknown_8459368[] = _("EXIT"); ALIGNED(4) const u8 gUnknown_8459370[] = _("INFO"); ALIGNED(4) const u8 gUnknown_8459378[] = _("NAME{CLEAR_TO 0x3C}WANTED{CLEAR_TO 0x6E}OFFER{CLEAR_TO 0xC6}LV."); -ALIGNED(4) const u8 gUnknown_8459394[] = _("SINGLE BATTLE"); -ALIGNED(4) const u8 gUnknown_84593A4[] = _("DOUBLE BATTLE"); -ALIGNED(4) const u8 gUnknown_84593B4[] = _("MULTI BATTLE"); -ALIGNED(4) const u8 gUnknown_84593C4[] = _("POKéMON TRADES"); -ALIGNED(4) const u8 gUnknown_84593D4[] = _("CHAT"); -ALIGNED(4) const u8 gUnknown_84593DC[] = _("CARDS"); -ALIGNED(4) const u8 gUnknown_84593E4[] = _("WONDER CARDS"); -ALIGNED(4) const u8 gUnknown_84593F4[] = _("WONDER NEWS"); -ALIGNED(4) const u8 gUnknown_8459400[] = _("POKéMON JUMP"); -ALIGNED(4) const u8 gUnknown_8459410[] = _("BERRY CRUSH"); -ALIGNED(4) const u8 gUnknown_845941C[] = _("BERRY-PICKING"); -ALIGNED(4) const u8 gUnknown_845942C[] = _("SEARCH"); -ALIGNED(4) const u8 gUnknown_8459434[] = _("ぐるぐるこうかん"); -ALIGNED(4) const u8 gUnknown_8459440[] = _("アイテムトレード"); + +ALIGNED(4) const u8 gUnionRoomActivity_SingleBattle[] = _("SINGLE BATTLE"); +ALIGNED(4) const u8 gUnionRoomActivity_DoubleBattle[] = _("DOUBLE BATTLE"); +ALIGNED(4) const u8 gUnionRoomActivity_MultiBattle[] = _("MULTI BATTLE"); +ALIGNED(4) const u8 gUnionRoomActivity_PokemonTrades[] = _("POKéMON TRADES"); +ALIGNED(4) const u8 gUnionRoomActivity_Chat[] = _("CHAT"); +ALIGNED(4) const u8 gUnionRoomActivity_Cards[] = _("CARDS"); +ALIGNED(4) const u8 gUnionRoomActivity_WonderCards[] = _("WONDER CARDS"); +ALIGNED(4) const u8 gunionRoomActivity_WonderNews[] = _("WONDER NEWS"); +ALIGNED(4) const u8 gUnionRoomActivity_PokemonJump[] = _("POKéMON JUMP"); +ALIGNED(4) const u8 gUnionRoomActivity_BerryCrush[] = _("BERRY CRUSH"); +ALIGNED(4) const u8 gUnionRoomActivity_BerryPicking[] = _("BERRY-PICKING"); +ALIGNED(4) const u8 gUnionRoomActivity_Search[] = _("SEARCH"); +ALIGNED(4) const u8 gUnionRoomActivity_SpinTradeJP[] = _("ぐるぐるこうかん"); +ALIGNED(4) const u8 gUnionRoomActivity_ItemTradeJP[] = _("アイテムトレード"); + ALIGNED(4) const u8 gUnknown_845944C[] = _("It's a NORMAL CARD."); ALIGNED(4) const u8 gUnknown_8459460[] = _("It's a BRONZE CARD!"); ALIGNED(4) const u8 gUnknown_8459474[] = _("It's a COPPER CARD!"); @@ -515,6 +525,7 @@ const u8 *const gUnknown_84594B0[] = { ALIGNED(4) const u8 gUnknown_84594C4[] = _("This is {SPECIAL_F7 0x00} {SPECIAL_F7 0x01}'s\nTRAINER CARD…\l{SPECIAL_F7 0x02}\pPOKéDEX: {SPECIAL_F7 0x03}\nTIME: {SPECIAL_F7 0x04}:{SPECIAL_F7 0x05}\p"); ALIGNED(4) const u8 gUnknown_8459504[] = _("BATTLES: {SPECIAL_F7 0x00} WINS {SPECIAL_F7 0x02} LOSSES\nTRADES: {SPECIAL_F7 0x03} TIMES\p“{SPECIAL_F7 0x04} {SPECIAL_F7 0x05}\n{SPECIAL_F7 0x06} {SPECIAL_F7 0x07}”\p"); + ALIGNED(4) const u8 gUnknown_8459544[] = _("{SPECIAL_F7 0x01}: Glad to have met you!{PAUSE 60}"); ALIGNED(4) const u8 gUnknown_8459564[] = _("{SPECIAL_F7 0x01}: Glad to meet you!{PAUSE 60}"); diff --git a/src/unk_815C980.c b/src/unk_815C980.c deleted file mode 100644 index 09b92c834..000000000 --- a/src/unk_815C980.c +++ /dev/null @@ -1,437 +0,0 @@ -#include "global.h" -#include "malloc.h" -#include "decompress.h" -#include "unk_815C980.h" -#include "main.h" -#include "battle.h" - -struct UnkStruct2 -{ - bool8 isActive; - u8 firstOamId; - u8 field_2; - u8 oamCount; - u8 palTagIndex; - u8 size; - u8 shape; - u8 priority; - u8 xDelta; - u8 field_9; - u16 tileStart; - s16 x; - s16 y; - u16 tileTag; - u16 palTag; - u32 field_14; - s32 field_18; -}; - -struct UnkStruct1 -{ - u32 count; - struct UnkStruct2 *array; -}; - -// this file's functions -static u8 sub_815D244(u8 arg0);; -static void sub_815CC28(struct UnkStruct2 *arg0); -static void sub_815CDDC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2); -static void sub_815CE90(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2); -static void sub_815CFEC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2); -static bool32 SharesTileWithAnyActive(u32 id); -static bool32 SharesPalWithAnyActive(u32 id); -static void sub_8035648(void); -static u8 sub_815D324(u32 shape, u32 size); - -// ewram -static EWRAM_DATA struct UnkStruct1 *gUnknown_203F454 = {0}; - -// const rom data -static const u8 gUnknown_8479658[][4] = -{ - {0x01, 0x04, 0x10, 0x40}, - {0x02, 0x04, 0x08, 0x20}, - {0x02, 0x04, 0x08, 0x20}, - {0x00, 0x00, 0x00, 0x00} -}; - -// code -bool32 sub_815C980(u32 count) -{ - u32 i; - - if (gUnknown_203F454 != NULL) - sub_815C9F4(); - - gUnknown_203F454 = Alloc(sizeof(*gUnknown_203F454)); - if (gUnknown_203F454 == NULL) - return FALSE; - - gUnknown_203F454->array = Alloc(sizeof(struct UnkStruct2) * count); - if (gUnknown_203F454->array == NULL) - { - Free(gUnknown_203F454); - return FALSE; - } - - gUnknown_203F454->count = count; - for (i = 0; i < count; i++) - { - gUnknown_203F454->array[i].isActive = FALSE; - gUnknown_203F454->array[i].firstOamId = 0xFF; - } - - return TRUE; -} - -void sub_815C9F4(void) -{ - if (gUnknown_203F454 != NULL) - { - if (gUnknown_203F454->array != NULL) - { - u32 i; - - for (i = 0; i < gUnknown_203F454->count; i++) - sub_815D108(i); - - Free(gUnknown_203F454->array); - } - - FREE_AND_SET_NULL(gUnknown_203F454); - } -} - -bool32 sub_815CA40(u32 id, s32 arg1, const struct UnkStruct3 *arg2) -{ - u32 i; - - if (gUnknown_203F454 == NULL) - return FALSE; - if (gUnknown_203F454->array[id].isActive) - return FALSE; - - gUnknown_203F454->array[id].firstOamId = sub_815D244(arg2->field_1); - if (gUnknown_203F454->array[id].firstOamId == 0xFF) - return FALSE; - - gUnknown_203F454->array[id].tileStart = GetSpriteTileStartByTag(arg2->spriteSheet->tag); - if (gUnknown_203F454->array[id].tileStart == 0xFFFF) - { - if (arg2->spriteSheet->size != 0) - { - gUnknown_203F454->array[id].tileStart = LoadSpriteSheet(arg2->spriteSheet); - } - else - { - struct CompressedSpriteSheet compObjectPic; - - compObjectPic = *(struct CompressedSpriteSheet*)(arg2->spriteSheet); - compObjectPic.size = GetDecompressedDataSize(arg2->spriteSheet->data); - gUnknown_203F454->array[id].tileStart = LoadCompressedSpriteSheet(&compObjectPic); - } - - if (gUnknown_203F454->array[id].tileStart == 0xFFFF) - return FALSE; - } - - gUnknown_203F454->array[id].palTagIndex = IndexOfSpritePaletteTag(arg2->spritePal->tag); - if (gUnknown_203F454->array[id].palTagIndex == 0xFF) - gUnknown_203F454->array[id].palTagIndex = LoadSpritePalette(arg2->spritePal); - - gUnknown_203F454->array[id].field_2 = arg2->field_0_0; - gUnknown_203F454->array[id].oamCount = arg2->field_1; - gUnknown_203F454->array[id].x = arg2->x; - gUnknown_203F454->array[id].y = arg2->y; - gUnknown_203F454->array[id].shape = arg2->shape; - gUnknown_203F454->array[id].size = arg2->size; - gUnknown_203F454->array[id].priority = arg2->priority; - gUnknown_203F454->array[id].xDelta = arg2->xDelta; - gUnknown_203F454->array[id].field_9 = sub_815D324(arg2->shape, arg2->size); - gUnknown_203F454->array[id].tileTag = arg2->spriteSheet->tag; - gUnknown_203F454->array[id].palTag = arg2->spritePal->tag; - gUnknown_203F454->array[id].isActive = TRUE; - gUnknown_203F454->array[id].field_14 = 1; - - for (i = 1; i < arg2->field_1; i++) - gUnknown_203F454->array[id].field_14 *= 10; - - sub_815CC28(&gUnknown_203F454->array[id]); - sub_815CD70(id, arg1); - - return TRUE; -} - -static void sub_815CC28(struct UnkStruct2 *arg0) -{ - u32 i; - u32 oamId = arg0->firstOamId; - u32 x = arg0->x; - u32 oamCount = arg0->oamCount + 1; - - CpuFill16(0, &gMain.oamBuffer[oamId], sizeof(struct OamData) * oamCount); - for (i = 0, oamId = arg0->firstOamId; i < oamCount; i++, oamId++) - { - gMain.oamBuffer[oamId].y = arg0->y; - gMain.oamBuffer[oamId].x = x; - gMain.oamBuffer[oamId].shape = arg0->shape; - gMain.oamBuffer[oamId].size = arg0->size; - gMain.oamBuffer[oamId].tileNum = arg0->tileStart; - gMain.oamBuffer[oamId].priority = arg0->priority; - gMain.oamBuffer[oamId].paletteNum = arg0->palTagIndex; - - x += arg0->xDelta; - } - - oamId--; - gMain.oamBuffer[oamId].x = arg0->x - arg0->xDelta; - gMain.oamBuffer[oamId].affineMode = 2; - gMain.oamBuffer[oamId].tileNum = arg0->tileStart + (arg0->field_9 * 10); -} - -void sub_815CD70(u32 id, s32 arg1) -{ - bool32 r2; - - if (gUnknown_203F454 == NULL) - return; - if (!gUnknown_203F454->array[id].isActive) - return; - - gUnknown_203F454->array[id].field_18 = arg1; - if (arg1 < 0) - { - r2 = TRUE; - arg1 *= -1; - } - else - { - r2 = FALSE; - } - - switch (gUnknown_203F454->array[id].field_2) - { - case 0: - default: - sub_815CDDC(&gUnknown_203F454->array[id], arg1, r2); - break; - case 1: - sub_815CE90(&gUnknown_203F454->array[id], arg1, r2); - break; - case 2: - sub_815CFEC(&gUnknown_203F454->array[id], arg1, r2); - break; - } -} - -static void sub_815CDDC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2) -{ - u32 r5 = arg0->field_14; - u32 oamId = arg0->firstOamId; - - while (r5 != 0) - { - u32 r4 = arg1 / r5; - arg1 -= (r4 * r5); - r5 /= 10; - - gMain.oamBuffer[oamId].tileNum = (r4 * arg0->field_9) + arg0->tileStart; - oamId++; - } - - if (arg2) - gMain.oamBuffer[oamId].affineMode = 0; - else - gMain.oamBuffer[oamId].affineMode = 2; -} - -static void sub_815CE90(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2) -{ - u32 r5 = arg0->field_14; - static int gUnknown_3002078; - static int gUnknown_300207C; - static int gUnknown_3002080; - - gUnknown_3002078 = arg0->firstOamId; - gUnknown_300207C = 0; - gUnknown_3002080 = -1; - - while (r5 != 0) - { - u32 r4 = arg1 / r5; - arg1 -= (r4 * r5); - r5 /= 10; - - if (r4 != 0 || gUnknown_3002080 != -1 || r5 == 0) - { - gMain.oamBuffer[gUnknown_3002078].tileNum = (r4 * arg0->field_9) + arg0->tileStart; - gMain.oamBuffer[gUnknown_3002078].affineMode = 0; - - if (gUnknown_3002080 == -1) - gUnknown_3002080 = gUnknown_300207C; - } - else - { - gMain.oamBuffer[gUnknown_3002078].affineMode = 2; - } - - gUnknown_3002078++; - gUnknown_300207C++; - } - - if (arg2) - { - gMain.oamBuffer[gUnknown_3002078].affineMode = 0; - gMain.oamBuffer[gUnknown_3002078].x = arg0->x + ((gUnknown_3002080 - 1) * arg0->xDelta); - } - else - { - gMain.oamBuffer[gUnknown_3002078].affineMode = 2; - } -} - -static void sub_815CFEC(struct UnkStruct2 *arg0, s32 arg1, bool32 arg2) -{ - u32 r5 = arg0->field_14; - u32 oamId = arg0->firstOamId; - u32 var_28 = 0; - s32 r9 = 0; - - while (r5 != 0) - { - u32 r4 = arg1 / r5; - arg1 -= (r4 * r5); - r5 /= 10; - - if (r4 != 0 || var_28 != 0 || r5 == 0) - { - var_28 = 1; - gMain.oamBuffer[oamId].tileNum = (r4 * arg0->field_9) + arg0->tileStart; - gMain.oamBuffer[oamId].affineMode = 0; - - oamId++; - r9++; - } - } - - while (r9 < arg0->oamCount) - { - gMain.oamBuffer[oamId].affineMode = 2; - oamId++; - r9++; - } - - if (arg2) - gMain.oamBuffer[oamId].affineMode = 0; - else - gMain.oamBuffer[oamId].affineMode = 2; -} - -void sub_815D108(u32 id) -{ - s32 oamId, oamCount, i; - - if (gUnknown_203F454 == NULL) - return; - if (!gUnknown_203F454->array[id].isActive) - return; - - oamCount = gUnknown_203F454->array[id].oamCount + 1; - oamId = gUnknown_203F454->array[id].firstOamId; - - for (i = 0; i < oamCount; i++, oamId++) - gMain.oamBuffer[oamId].affineMode = 2; - - if (!SharesTileWithAnyActive(id)) - FreeSpriteTilesByTag(gUnknown_203F454->array[id].tileTag); - if (!SharesPalWithAnyActive(id)) - FreeSpritePaletteByTag(gUnknown_203F454->array[id].palTag); - - gUnknown_203F454->array[id].isActive = FALSE; -} - -void sub_815D1A8(u32 id, bool32 arg1) -{ - s32 oamId, oamCount, i; - - if (gUnknown_203F454 == NULL) - return; - if (!gUnknown_203F454->array[id].isActive) - return; - - oamCount = gUnknown_203F454->array[id].oamCount + 1; - oamId = gUnknown_203F454->array[id].firstOamId; - if (arg1) - { - for (i = 0; i < oamCount; i++, oamId++) - gMain.oamBuffer[oamId].affineMode = 2; - } - else - { - for (i = 0; i < oamCount; i++, oamId++) - gMain.oamBuffer[oamId].affineMode = 0; - - sub_815CD70(id, gUnknown_203F454->array[id].field_18); - } -} - -static u8 sub_815D244(u8 arg0) -{ - u32 i; - u16 oamCount = 64; - - for (i = 0; i < gUnknown_203F454->count; i++) - { - if (!gUnknown_203F454->array[i].isActive) - { - if (gUnknown_203F454->array[i].firstOamId != 0xFF && gUnknown_203F454->array[i].oamCount <= arg0) - return gUnknown_203F454->array[i].firstOamId; - } - else - { - oamCount += 1 + gUnknown_203F454->array[i].oamCount; - } - } - - if (oamCount + arg0 + 1 > 128) - return 0xFF; - else - return oamCount; -} - -static bool32 SharesTileWithAnyActive(u32 id) -{ - u32 i; - - for (i = 0; i < gUnknown_203F454->count; i++) - { - if (gUnknown_203F454->array[i].isActive && i != id - && gUnknown_203F454->array[i].tileTag == gUnknown_203F454->array[id].tileTag) - { - return TRUE; - } - } - - return FALSE; -} - -static bool32 SharesPalWithAnyActive(u32 id) -{ - u32 i; - - for (i = 0; i < gUnknown_203F454->count; i++) - { - if (gUnknown_203F454->array[i].isActive && i != id - && gUnknown_203F454->array[i].palTag == gUnknown_203F454->array[id].palTag) - { - return TRUE; - } - } - - return FALSE; -} - -static u8 sub_815D324(u32 shape, u32 size) -{ - return gUnknown_8479658[shape][size]; -} diff --git a/src/vs_seeker.c b/src/vs_seeker.c index c0f53d5c2..9c9a4d67f 100644 --- a/src/vs_seeker.c +++ b/src/vs_seeker.c @@ -22,7 +22,6 @@ #include "field_player_avatar.h" #include "event_object_80688E4.h" #include "event_object_8097404.h" -#include "unk_810c3a4.h" #include "vs_seeker.h" #include "constants/movement_commands.h" #include "constants/object_events.h" diff --git a/src/wireless_communication_status_screen.c b/src/wireless_communication_status_screen.c index 9be2823aa..7267d4ace 100644 --- a/src/wireless_communication_status_screen.c +++ b/src/wireless_communication_status_screen.c @@ -13,40 +13,32 @@ #include "dynamic_placeholder_text_util.h" #include "overworld.h" #include "sound.h" +#include "strings.h" #include "menu.h" #include "librfu.h" #include "link_rfu.h" #include "union_room.h" #include "constants/songs.h" +#include "constants/union_room.h" struct WirelessCommunicationStatusScreenStruct { - u32 field_00[4]; - u32 field_10[4]; - u32 field_20[16]; - u8 field_60; - u8 field_61; + u32 counts[4]; + u32 lastCounts[4]; + u32 activities[16]; + u8 taskId; + u8 rfuTaskId; u8 filler_62[0xA]; }; -struct WirelessCommunicationStatusScreenStruct * gUnknown_3002040; +static struct WirelessCommunicationStatusScreenStruct * sWCSS; -extern const u8 gUnknown_841E2B4[]; -extern const u8 gUnknown_841E2BF[]; -extern const u8 gUnknown_841E2C9[]; -extern const u8 gUnknown_841E2D4[]; -extern const u8 gUnknown_841E245[]; -extern const u8 gUnknown_841E263[]; -extern const u8 gUnknown_841E273[]; -extern const u8 gUnknown_841E284[]; -extern const u8 gUnknown_841E29E[]; +static void CB2_InitWirelessCommunicationScreen(void); +static void Task_WirelessCommunicationScreen(u8 taskId); +static void WCSS_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx); +static bool32 UpdateCommunicationCounts(u32 * counts, u32 * lastCounts, u32 * activities, u8 taskId); -void sub_814F1E4(void); -void sub_814F46C(u8 taskId); -void sub_814F65C(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx); -bool32 sub_814F7E4(u32 * a0, u32 * a1, u32 * a2, u8 taskId); - -const u16 gUnknown_846F4D0[][16] = { +static const u16 sWCSS_Palettes[][16] = { INCBIN_U16("graphics/misc/unk_846f4d0.gbapal"), INCBIN_U16("graphics/misc/unk_846f4f0.gbapal"), INCBIN_U16("graphics/misc/unk_846f510.gbapal"), @@ -65,10 +57,10 @@ const u16 gUnknown_846F4D0[][16] = { INCBIN_U16("graphics/misc/unk_846f6b0.gbapal") }; -const u32 gUnknown_846F6D0[] = INCBIN_U32("graphics/misc/unk_846f6d0.4bpp.lz"); -const u16 gUnknown_846F8E0[] = INCBIN_U16("graphics/misc/unk_846f8e0.bin"); +static const u32 sBgTilesGfx[] = INCBIN_U32("graphics/misc/unk_846f6d0.4bpp.lz"); +static const u16 sBgTilemap[] = INCBIN_U16("graphics/misc/unk_846f8e0.bin"); -const struct BgTemplate gUnknown_846FA74[] = { +static const struct BgTemplate sBGTemplates[] = { { .bg = 0, .charBaseIndex = 2, @@ -88,7 +80,7 @@ const struct BgTemplate gUnknown_846FA74[] = { } }; -const struct WindowTemplate gUnknown_846FA7C[] = { +static const struct WindowTemplate sWindowTemplates[] = { { .bg = 0x00, .tilemapLeft = 0x03, @@ -116,47 +108,51 @@ const struct WindowTemplate gUnknown_846FA7C[] = { }, DUMMY_WIN_TEMPLATE }; -const u8 *const gUnknown_846FA9C[] = { +static const u8 *const gUnknown_846FA9C[] = { gUnknown_841E2B4, gUnknown_841E2BF, gUnknown_841E2C9, gUnknown_841E2D4 }; -const u8 *const gUnknown_846FAAC[] = { - gUnknown_841E245, - gUnknown_841E263, - gUnknown_841E273, - gUnknown_841E284, - gUnknown_841E29E + +static const u8 *const sHeaderTextPtrs[] = { + gText_WirelessCommunicationStatus, + gText_PeopleTrading, + gText_PeopleBattling, + gText_PeopleInUnionRoom, + gText_PeopleCommunicating }; -const u8 gUnknown_846FAC0[][3] = { - {0x01, 0x01, 0x02}, - {0x02, 0x01, 0x02}, - {0x03, 0x01, 0x04}, - {0x04, 0x00, 0x02}, - {0x15, 0x03, 0x02}, - {0x16, 0x03, 0x02}, - {0x09, 0x04, 0x00}, - {0x0a, 0x04, 0x00}, - {0x0b, 0x04, 0x00}, - {0x0c, 0xff, 0x00}, - {0x0d, 0x00, 0x00}, - {0x0e, 0xff, 0x00}, - {0x0f, 0x04, 0x00}, - {0x10, 0xff, 0x00}, - {0x40, 0x02, 0x01}, - {0x41, 0x02, 0x02}, - {0x44, 0x02, 0x02}, - {0x45, 0x02, 0x00}, - {0x48, 0x02, 0x02}, - {0x54, 0x02, 0x01}, - {0x53, 0x02, 0x02}, - {0x51, 0x02, 0x01}, - {0x52, 0x02, 0x01} +static const u8 sCountParams[][3] = { + // activity, count idx, by + // by=0 means count all + // UB: no check for count idx == -1 + {ACTIVITY_BATTLE, 1, 2}, + {ACTIVITY_DBLBATTLE, 1, 2}, + {ACTIVITY_MLTBATTLE, 1, 4}, + {ACTIVITY_TRADE, 0, 2}, + {ACTIVITY_WCARD2, 3, 2}, + {ACTIVITY_WNEWS2, 3, 2}, + {ACTIVITY_PJUMP, 4, 0}, + {ACTIVITY_BCRUSH, 4, 0}, + {ACTIVITY_BPICK, 4, 0}, + {ACTIVITY_SEARCH, -1, 0}, + {ACTIVITY_SPINTRADE, 0, 0}, + {ACTIVITY_ITEMTRADE, -1, 0}, + {0x0f, 4, 0}, + {0x10, -1, 0}, + {0x40, 2, 1}, + {ACTIVITY_BATTLE | 0x40, 2, 2}, + {ACTIVITY_TRADE | 0x40, 2, 2}, + {ACTIVITY_CHAT | 0x40, 2, 0}, + {ACTIVITY_CARD | 0x40, 2, 2}, + {20 | 0x40, 2, 1}, + {19 | 0x40, 2, 2}, + {ACTIVITY_ACCEPT | 0x40, 2, 1}, + {ACTIVITY_DECLINE | 0x40, 2, 1} }; -void sub_814F19C(void) +static void CB2_RunWirelessCommunicationScreen(void) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -168,50 +164,50 @@ void sub_814F19C(void) } } -void sub_814F1C0(void) +static void VBlankCB_WirelessCommunicationScreen(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -void sub_814F1D4(void) +void Special_WirelessCommunicationScreen(void) { - SetMainCallback2(sub_814F1E4); + SetMainCallback2(CB2_InitWirelessCommunicationScreen); } -void sub_814F1E4(void) +static void CB2_InitWirelessCommunicationScreen(void) { SetGpuReg(REG_OFFSET_DISPCNT, 0); - gUnknown_3002040 = AllocZeroed(sizeof(*gUnknown_3002040)); + sWCSS = AllocZeroed(sizeof(*sWCSS)); SetVBlankCallback(NULL); - ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, gUnknown_846FA74, NELEMS(gUnknown_846FA74)); + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sBGTemplates, NELEMS(sBGTemplates)); SetBgTilemapBuffer(1, Alloc(0x800)); SetBgTilemapBuffer(0, Alloc(0x800)); - DecompressAndLoadBgGfxUsingHeap(1, gUnknown_846F6D0, 0, 0, 0); - CopyToBgTilemapBuffer(1, gUnknown_846F8E0, 0, 0); - InitWindows(gUnknown_846FA7C); + DecompressAndLoadBgGfxUsingHeap(1, sBgTilesGfx, 0, 0, 0); + CopyToBgTilemapBuffer(1, sBgTilemap, 0, 0); + InitWindows(sWindowTemplates); DeactivateAllTextPrinters(); ResetPaletteFade(); ResetSpriteData(); ResetTasks(); ScanlineEffect_Stop(); m4aSoundVSyncOn(); - SetVBlankCallback(sub_814F1C0); - gUnknown_3002040->field_60 = CreateTask(sub_814F46C, 0); - gUnknown_3002040->field_61 = sub_8116DE0(); - gUnknown_3002040->field_10[3] = 1; + SetVBlankCallback(VBlankCB_WirelessCommunicationScreen); + sWCSS->taskId = CreateTask(Task_WirelessCommunicationScreen, 0); + sWCSS->rfuTaskId = CreateTask_ListenToWireless(); + sWCSS->lastCounts[3] = 1; ChangeBgX(0, 0, 0); ChangeBgY(0, 0, 0); ChangeBgX(1, 0, 0); ChangeBgY(1, 0, 0); - LoadPalette(gUnknown_846F4D0, 0, 0x20); + LoadPalette(sWCSS_Palettes, 0, 0x20); Menu_LoadStdPalAt(0xf0); DynamicPlaceholderTextUtil_Reset(); FillBgTilemapBufferRect(0, 0x000, 0, 0, 32, 32, 0xF); CopyBgTilemapBufferToVram(1); - SetMainCallback2(sub_814F19C); + SetMainCallback2(CB2_RunWirelessCommunicationScreen); RunTasks(); RunTextPrinters(); AnimateSprites(); @@ -219,7 +215,7 @@ void sub_814F1E4(void) UpdatePaletteFade(); } -void sub_814F32C(void) +static void ExitWirelessCommunicationStatusScreen(void) { s32 i; @@ -228,55 +224,55 @@ void sub_814F32C(void) { Free(GetBgTilemapBuffer(i)); } - Free(gUnknown_3002040); + Free(sWCSS); SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic); } -void sub_814F364(s16 * unk0, s16 * unk1) +static void WCSS_CyclePalette(s16 * frameCtr_p, s16 * palIdx_p) { s32 idx; - (*unk0)++; - if (*unk0 > 5) + (*frameCtr_p)++; + if (*frameCtr_p > 5) { - (*unk1)++; - if (*unk1 == 14) + (*palIdx_p)++; + if (*palIdx_p == 14) { - *unk1 = 0; + *palIdx_p = 0; } - *unk0 = 0; + *frameCtr_p = 0; } - idx = *unk1 + 2; - LoadPalette(gUnknown_846F4D0[idx], 0, 16); + idx = *palIdx_p + 2; + LoadPalette(sWCSS_Palettes[idx], 0, 16); } -void sub_814F3A8(void) +static void PrintHeaderTexts(void) { s32 i; u32 width; - FillWindowPixelBuffer(0, 0); - FillWindowPixelBuffer(1, 0); - FillWindowPixelBuffer(2, 0); - width = 0xC0 - GetStringWidth(3, gUnknown_846FAAC[0], 0); - sub_814F65C(0, 3, gUnknown_846FAAC[0], width / 2, 6, 3); + FillWindowPixelBuffer(0, PIXEL_FILL(0)); + FillWindowPixelBuffer(1, PIXEL_FILL(0)); + FillWindowPixelBuffer(2, PIXEL_FILL(0)); + width = 0xC0 - GetStringWidth(3, sHeaderTextPtrs[0], 0); + WCSS_AddTextPrinterParameterized(0, 3, sHeaderTextPtrs[0], width / 2, 6, 3); for (i = 0; i < 3; i++) { - sub_814F65C(1, 3, gUnknown_846FAAC[i + 1], 0, 30 * i + 10, 1); + WCSS_AddTextPrinterParameterized(1, 3, sHeaderTextPtrs[i + 1], 0, 30 * i + 10, 1); } - sub_814F65C(1, 3, gUnknown_846FAAC[i + 1], 0, 30 * i + 10, 2); + WCSS_AddTextPrinterParameterized(1, 3, sHeaderTextPtrs[i + 1], 0, 30 * i + 10, 2); PutWindowTilemap(0); CopyWindowToVram(0, 2); PutWindowTilemap(1); CopyWindowToVram(1, 2); } -void sub_814F46C(u8 taskId) +static void Task_WirelessCommunicationScreen(u8 taskId) { s32 i; switch (gTasks[taskId].data[0]) { case 0: - sub_814F3A8(); + PrintHeaderTexts(); gTasks[taskId].data[0]++; break; case 1: @@ -291,16 +287,16 @@ void sub_814F46C(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - if (sub_814F7E4(gUnknown_3002040->field_00, gUnknown_3002040->field_10, gUnknown_3002040->field_20, gUnknown_3002040->field_61)) + if (UpdateCommunicationCounts(sWCSS->counts, sWCSS->lastCounts, sWCSS->activities, sWCSS->rfuTaskId)) { - FillWindowPixelBuffer(2, 0x00); + FillWindowPixelBuffer(2, PIXEL_FILL(0)); for (i = 0; i < 4; i++) { - ConvertIntToDecimalStringN(gStringVar4, gUnknown_3002040->field_00[i], STR_CONV_MODE_RIGHT_ALIGN, 2); + ConvertIntToDecimalStringN(gStringVar4, sWCSS->counts[i], STR_CONV_MODE_RIGHT_ALIGN, 2); if (i != 3) - sub_814F65C(2, 3, gStringVar4, 4, 30 * i + 10, 1); + WCSS_AddTextPrinterParameterized(2, 3, gStringVar4, 4, 30 * i + 10, 1); else - sub_814F65C(2, 3, gStringVar4, 4, 100, 2); + WCSS_AddTextPrinterParameterized(2, 3, gStringVar4, 4, 100, 2); } PutWindowTilemap(2); CopyWindowToVram(2, 3); @@ -308,10 +304,10 @@ void sub_814F46C(u8 taskId) if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) { PlaySE(SE_SELECT); - gTasks[gUnknown_3002040->field_61].data[15] = 0xFF; + gTasks[sWCSS->rfuTaskId].data[15] = 0xFF; gTasks[taskId].data[0]++; } - sub_814F364(&gTasks[taskId].data[7], &gTasks[taskId].data[8]); + WCSS_CyclePalette(&gTasks[taskId].data[7], &gTasks[taskId].data[8]); break; case 4: BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); @@ -320,117 +316,117 @@ void sub_814F46C(u8 taskId) case 5: if (!gPaletteFade.active) { - SetMainCallback2(sub_814F32C); + SetMainCallback2(ExitWirelessCommunicationStatusScreen); DestroyTask(taskId); } break; } } -void sub_814F65C(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx) +static void WCSS_AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 * str, u8 x, u8 y, u8 palIdx) { u8 textColor[3]; switch (palIdx) { case 0: - textColor[0] = 0; - textColor[1] = 2; - textColor[2] = 3; + textColor[0] = TEXT_COLOR_TRANSPARENT; + textColor[1] = TEXT_COLOR_DARK_GREY; + textColor[2] = TEXT_COLOR_LIGHT_GREY; break; case 1: - textColor[0] = 0; - textColor[1] = 1; - textColor[2] = 3; + textColor[0] = TEXT_COLOR_TRANSPARENT; + textColor[1] = TEXT_COLOR_WHITE; + textColor[2] = TEXT_COLOR_LIGHT_GREY; break; case 2: - textColor[0] = 0; - textColor[1] = 4; - textColor[2] = 5; + textColor[0] = TEXT_COLOR_TRANSPARENT; + textColor[1] = TEXT_COLOR_RED; + textColor[2] = TEXT_COLOR_LIGHT_RED; break; case 3: - textColor[0] = 0; - textColor[1] = 7; - textColor[2] = 6; + textColor[0] = TEXT_COLOR_TRANSPARENT; + textColor[1] = TEXT_COLOR_LIGHT_GREEN; + textColor[2] = TEXT_COLOR_GREEN; break; case 4: - textColor[0] = 0; - textColor[1] = 1; - textColor[2] = 2; + textColor[0] = TEXT_COLOR_TRANSPARENT; + textColor[1] = TEXT_COLOR_WHITE; + textColor[2] = TEXT_COLOR_DARK_GREY; break; // default: UB } AddTextPrinterParameterized4(windowId, fontId,x, y, fontId == 0 ? 0 : 1, 0, textColor, -1, str); } -u32 sub_814F714(struct UnkStruct_x20 * unk20, u32 * arg1) +static u32 CountMembersInGroup(struct UnkStruct_x20 * unk20, u32 * counts) { - u32 r8 = unk20->unk.gname.unk_0a_0; + u32 activity = unk20->gname_uname.gname.activity; s32 i, j, k; - for (i = 0; i < NELEMS(gUnknown_846FAC0); i++) + for (i = 0; i < NELEMS(sCountParams); i++) { - if (r8 == gUnknown_846FAC0[i][0] && unk20->field_1A_0 == 1) + if (activity == sCountParams[i][0] && unk20->groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - if (gUnknown_846FAC0[i][2] == 0) + if (sCountParams[i][2] == 0) { k = 0; - for (j = 0; j < 4; j++) + for (j = 0; j < RFU_CHILD_MAX; j++) { - if (unk20->unk.gname.unk_04[j] != 0) k++; + if (unk20->gname_uname.gname.child_sprite_gender[j] != 0) k++; } k++; - arg1[gUnknown_846FAC0[i][1]] += k; + counts[sCountParams[i][1]] += k; } else { - arg1[gUnknown_846FAC0[i][1]] += gUnknown_846FAC0[i][2]; + counts[sCountParams[i][1]] += sCountParams[i][2]; } } } - return r8; + return activity; } -bool32 sub_814F7BC(const u32 * ptr0, const u32 * ptr1) +static bool32 HaveCountsChanged(const u32 * newCounts, const u32 * prevCounts) { s32 i; for (i = 0; i < 4; i++) { - if (ptr0[i] != ptr1[i]) + if (newCounts[i] != prevCounts[i]) return TRUE; } return FALSE; } -bool32 sub_814F7E4(u32 * a0, u32 * a1, u32 * a2, u8 taskId) +static bool32 UpdateCommunicationCounts(u32 * counts, u32 * lastCounts, u32 * activities, u8 taskId) { - bool32 r8 = FALSE; - u32 sp0[4] = {0, 0, 0, 0}; + bool32 activitiesUpdated = FALSE; + u32 buffer[4] = {0, 0, 0, 0}; struct UnkStruct_Group * group = (void *)gTasks[taskId].data; s32 i; for (i = 0; i < 16; i++) { - u32 r1 = sub_814F714(&group->field_0->arr[i], sp0); - if (r1 != a2[i]) + u32 activity = CountMembersInGroup(&group->field_0->arr[i], buffer); + if (activity != activities[i]) { - a2[i] = r1; - r8 = TRUE; + activities[i] = activity; + activitiesUpdated = TRUE; } } - if (sub_814F7BC(sp0, a1) == FALSE) + if (HaveCountsChanged(buffer, lastCounts) == FALSE) { - if (r8 == TRUE) + if (activitiesUpdated == TRUE) return TRUE; else return FALSE; } - memcpy(a0, sp0, sizeof(sp0)); - memcpy(a1, sp0, sizeof(sp0)); - a0[3] = a0[0] + a0[1] + a0[2]; + memcpy(counts, buffer, sizeof(buffer)); + memcpy(lastCounts, buffer, sizeof(buffer)); + counts[3] = counts[0] + counts[1] + counts[2]; return TRUE; } |