#include "global.h" #include "gflib.h" #include "librfu.h" #include "battle.h" #include "link.h" #include "link_rfu.h" #include "mystery_gift_menu.h" #include "overworld.h" #include "quest_log.h" #include "random.h" #include "task.h" #include "constants/union_room.h" struct SioInfo { char magic[15]; // PokemonSioInfo u8 playerCount; u8 linkPlayerIdx[RFU_CHILD_MAX]; struct LinkPlayer linkPlayers[MAX_RFU_PLAYERS]; u8 fill_a0[0x5c]; }; struct RfuDebug { u8 fill_00[6]; u16 unk_06; u8 fill_08[6]; vu8 unk_0e; u8 unk_0f; u8 fill_10[0x54]; u16 unk_64; u8 fill_66[0x1d]; u8 unk_83; u8 fill_84[0x58]; }; static EWRAM_DATA INIT_PARAM sRfuReqConfig = {}; static EWRAM_DATA struct RfuDebug sRfuDebug = {}; static u32 gf_rfu_REQ_api[RFU_API_BUFF_SIZE_RAM / 4]; static u8 sResendBlock8[14]; static u16 sResendBlock16[7]; struct GFtgtGname gHostRFUtgtGnameBuffer; GF_RFU_MANAGER Rfu; u8 gHostRFUtgtUnameBuffer[PLAYER_NAME_LENGTH + 1]; static void sub_80F8AA4(void); static void sub_80F8AEC(void); static void MscCallback_Child(u16 a0); static void MSCCallback_SetUnkCDB(u16 a0); static void UpdateBackupQueue(void); static void RfuHandleReceiveCommand(u8 unused); static void ResetSendDataManager(struct RfuBlockSend *data); static void RfuPrepareSendBuffer(u16 command); static void HandleBlockSend(void); static void SendNextBlock(void); static void SendLastBlock(void); static void CallRfuFunc(void); static void UpdateChildStatuses(void); static s32 GetRfuRecvStatus(void); static void sub_80FA834(u8 taskId); static void ClearSelectedLinkPlayerIds(u16 disconnectMask); static void ValidateAndReceivePokemonSioInfo(void * a0); static void Task_ExchangeLinkPlayers(u8 taskId); static void sub_80FACF0(u8 taskId); static void GetLinkmanErrorParams(u32 msg); static void sub_80FB564(s32 bmConnectedFlag); static void sub_80FBB74(void); 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 Debug_PrintEmpty(void); static void Task_idle(u8 taskId); static const INIT_PARAM sRfuReqConfigTemplate = { .maxMFrame = 4, .MC_TimerCount = 32, .availSlot_flag = 0, .mboot_flag = 0, .serialNo = 0x0002, .gameName = (void *)&gHostRFUtgtGnameBuffer, .userName = gHostRFUtgtUnameBuffer, .fastSearchParent_flag = TRUE, .linkRecovery_enable = FALSE, .linkRecovery_period = 600, .NI_failCounter_limit = 300 }; static const u8 sAvailSlots[] = { [1] = AVAIL_SLOT1, [2] = AVAIL_SLOT2, [3] = AVAIL_SLOT3, [4] = AVAIL_SLOT4 }; static const u32 sAllBlocksReceived[] = { 0x000000, 0x000001, 0x000003, 0x000007, 0x00000f, 0x00001f, 0x00003f, 0x00007f, 0x0000ff, 0x0001ff, 0x0003ff, 0x0007ff, 0x000fff, 0x001fff, 0x003fff, 0x007fff, 0x00ffff, 0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff, 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff }; static const u8 gUnknown_843EC38[] = { 0, 0, 1, 1, 2, 2, 2, 2, 3 }; static const u8 sNumSetBits[] = { [0x0] = 0, [0x1] = 1, [0x2] = 1, [0x3] = 2, [0x4] = 1, [0x5] = 2, [0x6] = 2, [0x7] = 3, [0x8] = 1, [0x9] = 2, [0xA] = 2, [0xB] = 3, [0xC] = 2, [0xD] = 3, [0xE] = 3, [0xF] = 4 }; static const u8 sNumTrailingZeroes[] = { [0x0] = 0, [0x1] = 0, [0x2] = 1, [0x3] = 0, [0x4] = 2, [0x5] = 0, [0x6] = 1, [0x7] = 0, [0x8] = 3, [0x9] = 0, [0xA] = 1, [0xB] = 0, [0xC] = 2, [0xD] = 0, [0xE] = 1, [0xF] = 0 }; static const struct BlockRequest sBlockRequests[] = { { gBlockSendBuffer, 200 }, { gBlockSendBuffer, 200 }, { gBlockSendBuffer, 100 }, { gBlockSendBuffer, 220 }, { gBlockSendBuffer, 40 } }; static const u16 sAcceptedSerialNos[] = { 0x0002, // Pokemon FR/LG/EM RFU_SERIAL_7F7D, 0xFFFF }; static const char sUnref_843EC92[][15] = { "RFU WAIT", "RFU BOOT", "RFU ERROR", "RFU RESET", "RFU CONFIG", "RFU START", "RFU SC POLL", "RFU SP POLL", "RFU START", "RFU SEND ERR", "RFU CP POLL" }; static const char sUnref_843ED37[][16] = { " ", "RECOVER START ", "DISSCONECT ", "RECOVER SUUSES", "RECOVER FAILED" }; static const TaskFunc gUnknown_843ED88[] = { sub_80FA834, Task_ExchangeLinkPlayers, sub_80FACF0 }; static void Debug_PrintString(const void *string, u8 x, u8 y) { // debug? } static void Debug_PrintNum(u16 num, u8 x, u8 y, u8 ndigits) { } void ResetLinkRfuGFLayer(void) { s32 i; u8 errorState_bak = Rfu.errorState; CpuFill16(0, &Rfu, sizeof Rfu); Rfu.parent_child = MODE_NEUTRAL; Rfu.errorState = errorState_bak; if (Rfu.errorState != 4) { Rfu.errorState = 0; } for (i = 0; i < MAX_RFU_PLAYERS; i++) { ResetSendDataManager(&Rfu.recvBlock[i]); } ResetSendDataManager(&Rfu.sendBlock); RfuRecvQueue_Reset(&Rfu.recvQueue); RfuSendQueue_Reset(&Rfu.sendQueue); CpuFill16(0, gSendCmd, sizeof gSendCmd); CpuFill16(0, gRecvCmds, sizeof gRecvCmds); CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers); } void InitRFU(void) { IntrFunc serialIntr = gIntrTable[1]; IntrFunc timerIntr = gIntrTable[2]; InitRFUAPI(); rfu_REQ_stopMode(); rfu_waitREQComplete(); REG_IME = 0; gIntrTable[1] = serialIntr; gIntrTable[2] = timerIntr; REG_IME = INTR_FLAG_VBLANK; } void InitRFUAPI(void) { if (!rfu_initializeAPI(gf_rfu_REQ_api, RFU_API_BUFF_SIZE_RAM, gIntrTable + 1, TRUE)) { gLinkType = 0; // ClearSavedLinkPlayers(); // Em fix sub_80FB128(FALSE); ResetLinkRfuGFLayer(); rfu_setTimerInterrupt(3, gIntrTable + 2); } } static void Task_LinkLeaderSearchForChildren(u8 taskId) { UpdateChildStatuses(); switch (Rfu.state) { case 0: rfu_LMAN_initializeRFU(&sRfuReqConfig); Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 2: rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos); Rfu.state = 3; gTasks[taskId].data[1] = 6; break; case 3: break; case 4: rfu_LMAN_stopManager(FALSE); Rfu.state = 5; break; case 5: break; case 18: Rfu.unk_cdb = FALSE; rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); sub_80F8AA4(); sub_80F8AEC(); Rfu.state = 20; gTasks[taskId].data[1] = 8; CreateTask(sub_80FA834, 5); DestroyTask(taskId); break; } } static u8 CountTrailingZeroes(u8 acceptSlot) { return sNumTrailingZeroes[acceptSlot]; } static void ReassignPartnerIds(s32 before, s32 after) { u8 i; u8 r4 = 1; s32 beforeBak = before; s32 r6 = 0; if (after == -1) { // First Time Init // UB: linkPlayerIdx may be uninitialized for (i = 0; i < RFU_CHILD_MAX; before >>= 1, i++) { if (before & 1) { Rfu.linkPlayerIdx[i] = r4; r4++; } } } else { // Delete before flags for (i = 0; i < RFU_CHILD_MAX; beforeBak >>= 1, i++) { if (!(beforeBak & 1)) { Rfu.linkPlayerIdx[i] = 0; } } // Get highest retained index for (r4 = 4; r4 != 0; r4--) { for (i = 0; i < RFU_CHILD_MAX && Rfu.linkPlayerIdx[i] != r4; i++); if (i == 4) { r6 = r4; } } // Replace with new flags for (after &= ~before, i = 0; i < RFU_CHILD_MAX; after >>= 1, i++) { if (after & 1) { Rfu.linkPlayerIdx[i] = r6++; } } } } static void Task_JoinGroupSearchForParent(u8 taskId) { switch (Rfu.state) { case 0: rfu_LMAN_initializeRFU((INIT_PARAM*)&sRfuReqConfigTemplate); Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 6: rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16*)sAcceptedSerialNos); Rfu.state = 7; gTasks[taskId].data[1] = 7; break; case 7: break; case 9: gTasks[taskId].data[1] = 10; break; case 11: switch (GetRfuRecvStatus()) { case RFU_STATUS_JOIN_GROUP_OK: Rfu.state = 12; break; case RFU_STATUS_JOIN_GROUP_NO: case RFU_STATUS_LEAVE_GROUP: rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 2; DestroyTask(taskId); break; } break; case 12: { 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.lastCmdBeforeCommInterrupt, sizeof(Rfu.lastCmdBeforeCommInterrupt)); gTasks[taskId].data[1] = 8; DestroyTask(taskId); if (sRfuDebug.unk_0f == 0) { Debug_PrintEmpty(); sRfuDebug.unk_0f++; } CreateTask(sub_80FA834, 5); break; } } } static void sub_80F8AA4(void) { u8 i; u8 acceptSlot = lman.acceptSlot_flag; for (i = 0; i < RFU_CHILD_MAX; i++) { if (acceptSlot & 1) { rfu_setRecvBuffer(TYPE_UNI, i, Rfu.main_UNI_recvBuffer[i], sizeof(Rfu.main_UNI_recvBuffer[i])); rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, i); } acceptSlot >>= 1; } } static void sub_80F8AEC(void) { u8 acceptSlot = lman.acceptSlot_flag; rfu_UNI_setSendData(acceptSlot, Rfu.recvCmds, sizeof(Rfu.recvCmds)); Rfu.unk_cda = CountTrailingZeroes(acceptSlot); Rfu.bm_PartnerFlags = acceptSlot; ReassignPartnerIds(acceptSlot, -1); Rfu.parent_child = MODE_PARENT; } static void Task_LinkRfu_UnionRoomListen(u8 taskId) { if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM) && RfuGetStatus() == 4) { rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); RfuSetStatus(RFU_STATUS_OK, 0); } switch (Rfu.state) { case 0: rfu_LMAN_initializeRFU(&sRfuReqConfig); Rfu.state = 1; gTasks[taskId].data[1] = 1; break; case 1: break; case 17: rfu_LMAN_establishConnection(MODE_P_C_SWITCH, 0, 240, (u16*)sAcceptedSerialNos); rfu_LMAN_setMSCCallback(MscCallback_Child); Rfu.state = 18; break; case 18: break; case 13: if (rfu_UNI_setSendData(1 << Rfu.child_slot, Rfu.lastCmdBeforeCommInterrupt, sizeof(Rfu.lastCmdBeforeCommInterrupt)) == 0) { Rfu.parent_child = MODE_CHILD; DestroyTask(taskId); if (gTasks[taskId].data[7]) { CreateTask(sub_80FACF0, 1); } else { CreateTask(sub_80FA834, 5); } } break; case 14: rfu_LMAN_stopManager(0); Rfu.state = 15; break; case 15: break; case 16: Rfu.unk_cdb = FALSE; rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); UpdateGameData_GroupLockedIn(1); sub_80F8AA4(); sub_80F8AEC(); Rfu.state = 20; gTasks[taskId].data[1] = 8; Rfu.parent_child = MODE_PARENT; CreateTask(sub_80FA834, 5); Rfu.foundNewLeaderMaybe = TRUE; DestroyTask(taskId); break; } } void LinkRfu_CreateConnectionAsParent(void) { rfu_LMAN_establishConnection(MODE_PARENT, 0, 240, (u16*)sAcceptedSerialNos); } void LinkRfu_StopManagerBeforeEnteringChat(void) { rfu_LMAN_stopManager(FALSE); } static void MscCallback_Child(u16 unused) { s32 i; for (i = 0; i < BACKUP_QUEUE_SLOT_LENGTH; i++) { Rfu.lastCmdBeforeCommInterrupt[i] = 0; } rfu_REQ_recvData(); rfu_waitREQComplete(); if (gRfuSlotStatusUNI[Rfu.child_slot]->recv.newDataFlag) { Rfu.sem_UNI_SendRecv++; RfuRecvQueue_Enqueue(&Rfu.recvQueue, Rfu.unk_c3f); sRfuDebug.unk_06++; UpdateBackupQueue(); rfu_UNI_readySendData(Rfu.child_slot); rfu_UNI_clearRecvNewDataFlag(Rfu.child_slot); } rfu_LMAN_REQ_sendData(TRUE); } static void MSCCallback_SetUnkCDB(u16 unused) { Rfu.unk_cdb = TRUE; } void LinkRfu_Shutdown(void) { u8 i; if (QL_IS_PLAYBACK_STATE) return; rfu_LMAN_powerDownRFU(); if (Rfu.parent_child == MODE_PARENT) { if (FuncIsActiveTask(Task_LinkLeaderSearchForChildren) == TRUE) { DestroyTask(Rfu.searchTaskId); ResetLinkRfuGFLayer(); } } else if (Rfu.parent_child == MODE_CHILD) { if (FuncIsActiveTask(Task_JoinGroupSearchForParent) == TRUE) { DestroyTask(Rfu.searchTaskId); ResetLinkRfuGFLayer(); } } else if (Rfu.parent_child == 2) { if (FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) { DestroyTask(Rfu.searchTaskId); ResetLinkRfuGFLayer(); } } for (i = 0; i < NELEMS(gUnknown_843ED88); i++) { if (FuncIsActiveTask(gUnknown_843ED88[i]) == TRUE) { DestroyTask(FindTaskIdByFunc(gUnknown_843ED88[i])); } } } static void CreateTask_LinkLeaderSearchForChildren(void) { if (QL_IS_PLAYBACK_STATE) return; Rfu.searchTaskId = CreateTask(Task_LinkLeaderSearchForChildren, 1); } static bool8 ContactedByParentAttemptingToReconnect(void) { if (Rfu.state == 7 && Rfu.parentId) { return TRUE; } return FALSE; } static bool32 IsParentSuccessfullyReconnected(void) { if (Rfu.state == 7 && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[Rfu.reconnectedParentIdx].id, 240)) { Rfu.state = 9; return TRUE; } return FALSE; } static void CreateTask_JoinGroupSearchForParent(void) { if (QL_IS_PLAYBACK_STATE) return; Rfu.searchTaskId = CreateTask(Task_JoinGroupSearchForParent, 1); } bool8 LmanAcceptSlotFlagIsNotZero(void) { if (lman.acceptSlot_flag) { return TRUE; } return FALSE; } void LinkRfu_StopManagerAndFinalizeSlots(void) { Rfu.state = 4; Rfu.acceptSlot_flag = lman.acceptSlot_flag; } bool32 WaitRfuState(bool32 force) { if (Rfu.state == 17 || force) { Rfu.state = 18; return TRUE; } return FALSE; } void sub_80F8FA0(void) { Rfu.state = 14; } UNUSED static void sub_80F8FAC(u8 a0) { u8 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if (a0 & 1) { rfu_UNI_readySendData(i); break; } a0 >>= 1; } } static void MoveRecvCmdsToRfuBuffer(void) { s32 i, j; for (i = 0; i < MAX_RFU_PLAYERS; i++) { GF_RFU_MANAGER *ptr = &Rfu; for (j = 0; j < CMD_LENGTH - 1; j++) { ptr->recvCmds[i][j][1] = gRecvCmds[i][j] >> 8; ptr->recvCmds[i][j][0] = gRecvCmds[i][j]; } } CpuFill16(0, gRecvCmds, sizeof gRecvCmds); } static void MoveSendCmdToFirstRecvCmd(void) { s32 i; for (i = 0; i < CMD_LENGTH - 1; i++) { gRecvCmds[0][i] = gSendCmd[i]; } for (i = 0; i < CMD_LENGTH - 1; i++) { gSendCmd[i] = 0; } } static void UpdateBackupQueue(void) { if (Rfu.linkRecovered) { bool8 backupEmpty = RfuBackupQueue_Dequeue(&Rfu.backupQueue, Rfu.lastCmdBeforeCommInterrupt); if (Rfu.backupQueue.count == 0) { Rfu.linkRecovered = FALSE; } if (backupEmpty) { return; } } if (!Rfu.linkRecovered) { RfuSendQueue_Dequeue(&Rfu.sendQueue, Rfu.lastCmdBeforeCommInterrupt); RfuBackupQueue_Enqueue(&Rfu.backupQueue, Rfu.lastCmdBeforeCommInterrupt); } } bool32 IsRfuRecvQueueEmpty(void) { s32 i; s32 j; if (gRfuLinkStatus->sendSlotUNIFlag == 0) { return FALSE; } for (i = 0; i < MAX_RFU_PLAYERS; i++) { for (j = 0; j < CMD_LENGTH - 1; j++) { if (gRecvCmds[i][j] != 0) { return FALSE; } } } return TRUE; } static bool32 sub_80F911C(void) { if (Rfu.state < 20) { rfu_REQ_recvData(); rfu_waitREQComplete(); rfu_LMAN_REQ_sendData(FALSE); } else { Rfu.unk_cdb = FALSE; if ((Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag) == Rfu.bm_PartnerFlags && (Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag)) { if (!Rfu.unk_cdc) { if (Rfu.bm_DisconnectSlot) { RfuReqDisconnectSlot(Rfu.bm_DisconnectSlot); Rfu.bm_DisconnectSlot = 0; if (Rfu.unk_ce4 == 1) { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x8000); GetLinkmanErrorParams(0x8000); return FALSE; } if (!lman.acceptSlot_flag) { LinkRfu_Shutdown(); gReceivedRemoteLinkPlayers = FALSE; return FALSE; } } MoveRecvCmdsToRfuBuffer(); rfu_UNI_readySendData(Rfu.unk_cda); rfu_LMAN_REQ_sendData(TRUE); } else { rfu_REQ_PARENT_resumeRetransmitAndChange(); } Rfu.unk_0e = TRUE; } } return FALSE; } static bool32 sub_80F9204(void) { u16 i; u16 flags; u8 r0; u16 j; u8 retval; if (Rfu.state >= 20 && Rfu.unk_0e == TRUE) { rfu_waitREQComplete(); while (!Rfu.unk_cdb) { if (Rfu.errorState != 0) { return FALSE; } } rfu_REQ_recvData(); rfu_waitREQComplete(); if ((lman.parentAck_flag & Rfu.bm_PartnerFlags) == Rfu.bm_PartnerFlags) { Rfu.unk_cdc = 0; sRfuDebug.unk_06++; flags = lman.acceptSlot_flag; for (i = 0; i < RFU_CHILD_MAX; i++) { if (flags & 1) { if (Rfu.main_UNI_recvBuffer[i][1]) { if (Rfu.unk_cee[i] != 0xFF && (Rfu.main_UNI_recvBuffer[i][0] >> 5) != ((Rfu.unk_cee[i] + 1) & 7)) { if (++Rfu.unk_cea[i] > 4) GetLinkmanErrorParams(0x8100); } else { Rfu.unk_cee[i] = Rfu.main_UNI_recvBuffer[i][0] / 32; Rfu.unk_cea[i] = 0; Rfu.main_UNI_recvBuffer[i][0] &= 0x1f; r0 = Rfu.linkPlayerIdx[i]; for (j = 0; j < 7; j++) { gRecvCmds[r0][j] = (Rfu.main_UNI_recvBuffer[i][(j << 1) + 1] << 8) | Rfu.main_UNI_recvBuffer[i][(j << 1) + 0]; Rfu.main_UNI_recvBuffer[i][(j << 1) + 1] = 0; Rfu.main_UNI_recvBuffer[i][(j << 1) + 0] = 0; } } } rfu_UNI_clearRecvNewDataFlag(i); } flags >>= 1; } MoveSendCmdToFirstRecvCmd(); RfuHandleReceiveCommand(0); CallRfuFunc(); if (Rfu.bmChatLeaderMaybe && !Rfu.linkClosing) { sRfuDebug.unk_0e = FALSE; rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, Rfu.unk_cda); for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.bmChatLeaderMaybe >> i) & 1) { rfu_setRecvBuffer(TYPE_UNI, i, Rfu.main_UNI_recvBuffer[i], sizeof(Rfu.main_UNI_recvBuffer[i])); } } ReassignPartnerIds(Rfu.bm_PartnerFlags, Rfu.bm_PartnerFlags | Rfu.bmChatLeaderMaybe); Rfu.unk_ce9 = Rfu.bmChatLeaderMaybe; Rfu.bm_PartnerFlags |= Rfu.bmChatLeaderMaybe; Rfu.bmChatLeaderMaybe = 0; rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, sizeof(Rfu.recvCmds)); Rfu.unk_cda = CountTrailingZeroes(Rfu.bm_PartnerFlags); CreateTask(Task_ExchangeLinkPlayers, 0); } } else { Rfu.unk_cdc = 1; Rfu.unk_0e = FALSE; } Rfu.unk_0e = FALSE; } retval = Rfu.unk_cdc; return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE; } static void RfuBufferSendCmd(u16 *sendCmd, u8 *rfuSendBuf) { s32 i; if (sendCmd[0]) { sendCmd[0] |= (Rfu.unk_102 << 5); Rfu.unk_102 = (Rfu.unk_102 + 1) & 7; for (i = 0; i < 7; i++) { rfuSendBuf[2 * i + 1] = sendCmd[i] >> 8; rfuSendBuf[2 * i + 0] = sendCmd[i]; } } else { for (i = 0; i < 14; i++) rfuSendBuf[i] = 0; } } static bool32 RfuProcessEnqueuedRecvBlock(void) { u8 i; u8 j; u8 recvBuf[MAX_RFU_PLAYERS * (2 * (CMD_LENGTH - 1))]; u8 sendBuf[2 * (CMD_LENGTH - 1)]; u8 status; RfuRecvQueue_Dequeue(&Rfu.recvQueue, recvBuf); for (i = 0; i < MAX_RFU_PLAYERS; i++) { for (j = 0; j < CMD_LENGTH - 1; j++) { gRecvCmds[i][j] = (recvBuf[i * 14 + (j << 1) + 1] << 8) | recvBuf[i * 14 + (j << 1) + 0]; } } RfuHandleReceiveCommand(0); if (lman.childClockSlave_flag == 0 && Rfu.unk_ce4) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); status = RfuGetStatus(); if (status != RFU_STATUS_FATAL_ERROR && status != RFU_STATUS_JOIN_GROUP_NO && status != RFU_STATUS_LEAVE_GROUP) RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x9000); rfu_clearAllSlot(); gReceivedRemoteLinkPlayers = FALSE; Rfu.RfuFunc = NULL; if (Rfu.unk_ce4 == 1) { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x9000); GetLinkmanErrorParams(0x9000); } lman.state = lman.next_state = 0; Rfu.unk_ce4 = 0; } if (Rfu.sem_UNI_SendRecv) { Rfu.sem_UNI_SendRecv--; CallRfuFunc(); RfuBufferSendCmd(gSendCmd, sendBuf); RfuSendQueue_Enqueue(&Rfu.sendQueue, sendBuf); for (i = 0; i < CMD_LENGTH - 1; i++) gSendCmd[i] = 0; } return IsRfuRecvQueueEmpty(); } static void HandleSendFailure(u8 unused, u32 flags) { s32 i, j, temp; const u8 *payload = Rfu.sendBlock.payload; for (i = 0; i < Rfu.sendBlock.count; i++) { if (!(flags & 1)) { sResendBlock16[0] = RFUCMD_SEND_BLOCK_STEP | i; for (j = 0; j < 7; j++) { temp = j << 1; sResendBlock16[j + 1] = (payload[12 * i + temp + 1] << 8) | payload[12 * i + temp + 0]; } for (j = 0; j < 7; j++) { temp = j << 1; sResendBlock8[temp + 1] = sResendBlock16[j] >> 8; sResendBlock8[temp + 0] = sResendBlock16[j]; } RfuSendQueue_Enqueue(&Rfu.sendQueue, sResendBlock8); Rfu.sendBlock.failedFlags |= (1 << i); } flags >>= 1; } } void Rfu_SetBlockReceivedFlag(u8 linkPlayerId) { if (Rfu.parent_child == MODE_PARENT && linkPlayerId != 0) Rfu.numBlocksReceived[linkPlayerId] = 1; else Rfu.blockReceived[linkPlayerId] = TRUE; } void Rfu_ResetBlockReceivedFlag(u8 linkPlayerId) { Rfu.blockReceived[linkPlayerId] = FALSE; Rfu.recvBlock[linkPlayerId].receiving = RFU_RECV_IDLE; } static u8 RfuChildSetReceivedPlayerOrder(const u8 *template) { u8 i; if (Rfu.parent_child == MODE_PARENT) return FALSE; for (i = 0; i < RFU_CHILD_MAX; i++) { Rfu.linkPlayerIdx[i] = template[i]; } return template[Rfu.child_slot]; } static void RfuFunc_SendKeysToRfu(void) { static u8 heldKeyCount; if (gReceivedRemoteLinkPlayers && gHeldKeyCodeToSend != LINK_KEY_CODE_NULL && gLinkTransferringData != TRUE) { heldKeyCount++; gHeldKeyCodeToSend |= (heldKeyCount << 8); RfuPrepareSendBuffer(RFUCMD_SEND_HELD_KEYS); } } struct GFtgtGname *GetHostRFUtgtGname(void) { return &gHostRFUtgtGnameBuffer; } bool32 IsSendingKeysToRfu(void) { return Rfu.RfuFunc == RfuFunc_SendKeysToRfu; } void StartSendingKeysToRfu(void) { AGB_ASSERT_EX(Rfu.RfuFunc == NULL, ABSPATH("rfu.c"), 1473); Rfu.RfuFunc = RfuFunc_SendKeysToRfu; } void ClearLinkRfuCallback(void) { Rfu.RfuFunc = NULL; } static void RfuHandleReceiveCommand(u8 unused) { u16 i; u16 j; for (i = 0; i < MAX_RFU_PLAYERS; i++) { switch (gRecvCmds[i][0] & 0xff00) { case RFUCMD_PLAYERS_LIST_2: if (Rfu.parent_child == MODE_CHILD && gReceivedRemoteLinkPlayers) return; // fallthrough case RFUCMD_PLAYERS_LIST: if (gRfuLinkStatus->parentChild == MODE_CHILD) { Rfu.playerCount = gRecvCmds[i][1]; Rfu.multiplayerId = RfuChildSetReceivedPlayerOrder((u8 *)(gRecvCmds[i] + 2)); } break; case RFUCMD_SEND_BLOCK_INIT: if (Rfu.recvBlock[i].receiving == RFU_RECV_IDLE) { Rfu.recvBlock[i].next = 0; Rfu.recvBlock[i].count = gRecvCmds[i][1]; Rfu.recvBlock[i].owner = gRecvCmds[i][2]; Rfu.recvBlock[i].receivedFlags = 0; Rfu.recvBlock[i].receiving = RFU_RECV_RECEIVING; Rfu.blockReceived[i] = FALSE; } break; case RFUCMD_SEND_BLOCK_STEP: if (Rfu.recvBlock[i].receiving == RFU_RECV_RECEIVING) { Rfu.recvBlock[i].next = gRecvCmds[i][0] & 0xff; Rfu.recvBlock[i].receivedFlags |= (1 << Rfu.recvBlock[i].next); for (j = 0; j < 6; j++) gBlockRecvBuffer[i][Rfu.recvBlock[i].next * 6 + j] = gRecvCmds[i][j + 1]; if (Rfu.recvBlock[i].receivedFlags == sAllBlocksReceived[Rfu.recvBlock[i].count]) { Rfu.recvBlock[i].receiving = RFU_RECV_FINISHED; Rfu_SetBlockReceivedFlag(i); if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers && Rfu.parent_child == MODE_CHILD) ValidateAndReceivePokemonSioInfo(gBlockRecvBuffer); } } break; case RFUCMD_SEND_BLOCK_REQ: Rfu_InitBlockSend(sBlockRequests[gRecvCmds[i][1]].address, (u16)sBlockRequests[gRecvCmds[i][1]].size); break; case RFUCMD_READY_CLOSE_LINK: Rfu.readyCloseLink[i] = TRUE; break; case RFUCMD_READY_EXIT_STANDBY: if (Rfu.resendExitStandbyCount == gRecvCmds[i][1]) Rfu.readyExitStandby[i] = TRUE; break; case RFUCMD_PARENT_DISCONNECT: if (Rfu.parent_child == MODE_CHILD) { if (gReceivedRemoteLinkPlayers) { if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag) { gReceivedRemoteLinkPlayers = FALSE; rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = gRecvCmds[i][2]; } Rfu.playerCount = gRecvCmds[i][3]; ClearSelectedLinkPlayerIds(gRecvCmds[i][1]); } } else { RfuPrepareSendBuffer(RFUCMD_CHILD_DISCONNECT); gSendCmd[1] = gRecvCmds[i][1]; gSendCmd[2] = gRecvCmds[i][2]; gSendCmd[3] = gRecvCmds[i][3]; } break; case RFUCMD_CHILD_DISCONNECT: if (Rfu.parent_child == MODE_PARENT) { Rfu.bm_DisconnectSlot |= gRecvCmds[i][1]; Rfu.unk_ce4 = gRecvCmds[i][2]; ClearSelectedLinkPlayerIds(gRecvCmds[i][1]); } break; case RFUCMD_SEND_HELD_KEYS: gLinkPartnersHeldKeys[i] = gRecvCmds[i][1]; break; } if (Rfu.parent_child == MODE_PARENT && Rfu.numBlocksReceived[i]) { if (Rfu.numBlocksReceived[i] == 4) { Rfu.blockReceived[i] = TRUE; Rfu.numBlocksReceived[i] = 0; } else Rfu.numBlocksReceived[i]++; } } } static bool8 AreNoPlayersReceiving(void) { s32 i; for (i = 0; i < 5; i++) { if (Rfu.recvBlock[i].receiving != RFU_RECV_IDLE) return FALSE; } return TRUE; } static bool8 AreAllPlayersFinishedReceiving(void) { s32 i; for (i = 0; i < Rfu.playerCount; i++) { if (Rfu.recvBlock[i].receiving != RFU_RECV_FINISHED || Rfu.blockReceived[i] != TRUE) return FALSE; } return TRUE; } static void ResetSendDataManager(struct RfuBlockSend *data) { data->next = 0; data->count = 0; data->payload = NULL; data->receivedFlags = 0; data->sending = 0; data->owner = 0; data->receiving = RFU_RECV_IDLE; } u8 Rfu_GetBlockReceivedStatus(void) { u8 flags = 0; s32 i; for (i = 0; i < 5; i++) { if (Rfu.recvBlock[i].receiving == RFU_RECV_FINISHED && Rfu.blockReceived[i] == TRUE) { flags |= (1 << i); } } return flags; } static void RfuPrepareSendBuffer(u16 command) { u8 i; u8 *buff; u8 tmp; gSendCmd[0] = command; switch (command) { case RFUCMD_SEND_BLOCK_INIT: gSendCmd[1] = Rfu.sendBlock.count; gSendCmd[2] = Rfu.sendBlock.owner + 0x80; break; case RFUCMD_SEND_BLOCK_REQ: if (AreNoPlayersReceiving()) gSendCmd[1] = Rfu.cmdA100_blockRequestType; break; case RFUCMD_PLAYERS_LIST: case RFUCMD_PLAYERS_LIST_2: tmp = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; Rfu.playerCount = sNumSetBits[tmp] + 1; gSendCmd[1] = Rfu.playerCount; buff = (u8 *)(gSendCmd + 2); for (i = 0; i < RFU_CHILD_MAX; i++) buff[i] = Rfu.linkPlayerIdx[i]; break; case RFUCMD_READY_EXIT_STANDBY: case RFUCMD_READY_CLOSE_LINK: gSendCmd[1] = Rfu.resendExitStandbyCount; break; case RFUCMD_SEND_PACKET: for (i = 0; i < 6; i++) gSendCmd[1 + i] = Rfu.packet[i]; break; case RFUCMD_SEND_HELD_KEYS: gSendCmd[1] = gHeldKeyCodeToSend; break; case RFUCMD_CHILD_DISCONNECT: break; case RFUCMD_PARENT_DISCONNECT: break; } } void Rfu_SendPacket(void * data) { if (IsSendCmdComplete() && !RfuHasErrored()) { memcpy(Rfu.packet, data, sizeof(Rfu.packet)); RfuPrepareSendBuffer(RFUCMD_SEND_PACKET); } } bool32 Rfu_InitBlockSend(const u8 *src, size_t size) { bool8 sizeHasModulo; AGB_ASSERT_EX(size<=252, ABSPATH("rfu.c"), 1793); if (Rfu.RfuFunc != NULL) return FALSE; if (gSendCmd[0] != 0) return FALSE; if (Rfu.sendBlock.sending != 0) { sRfuDebug.unk_83++; return FALSE; } sizeHasModulo = (size % 12) != 0; Rfu.sendBlock.owner = GetMultiplayerId(); Rfu.sendBlock.sending = 1; Rfu.sendBlock.count = (size / 12) + sizeHasModulo; Rfu.sendBlock.next = 0; if (size > 0x100) // should never be reached Rfu.sendBlock.payload = src; else { if (src != gBlockSendBuffer) memcpy(gBlockSendBuffer, src, size); Rfu.sendBlock.payload = gBlockSendBuffer; } RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT); Rfu.RfuFunc = HandleBlockSend; Rfu.sendBlockInitDelay = 0; return TRUE; } static void HandleBlockSend(void) { if (IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT); if (Rfu.parent_child == MODE_PARENT) { if (++Rfu.sendBlockInitDelay > 2) Rfu.RfuFunc = SendNextBlock; } else { if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFUCMD_SEND_BLOCK_INIT) Rfu.RfuFunc = SendNextBlock; } } } static void SendNextBlock(void) { s32 i; const u8 *src = Rfu.sendBlock.payload; gSendCmd[0] = RFUCMD_SEND_BLOCK_STEP | Rfu.sendBlock.next; for (i = 0; i < 7; i++) gSendCmd[i + 1] = (src[(i << 1) + Rfu.sendBlock.next * 12 + 1] << 8) | src[(i << 1) + Rfu.sendBlock.next * 12 + 0]; Rfu.sendBlock.next++; if (Rfu.sendBlock.count <= Rfu.sendBlock.next) { Rfu.sendBlock.sending = 0; Rfu.RfuFunc = SendLastBlock; } } static void SendLastBlock(void) { const u8 *src = Rfu.sendBlock.payload; u8 mpId = GetMultiplayerId(); s32 i; if (Rfu.parent_child == MODE_CHILD) { gSendCmd[0] = RFUCMD_SEND_BLOCK_STEP | (Rfu.sendBlock.count - 1); for (i = 0; i < 7; i++) gSendCmd[i + 1] = (src[(i << 1) + (Rfu.sendBlock.count - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.sendBlock.count - 1) * 12 + 0]; if ((u8)gRecvCmds[mpId][0] == Rfu.sendBlock.count - 1) { if (Rfu.recvBlock[mpId].receivedFlags != sAllBlocksReceived[Rfu.recvBlock[mpId].count]) { HandleSendFailure(mpId, Rfu.recvBlock[mpId].receivedFlags); sRfuDebug.unk_64++; } else Rfu.RfuFunc = NULL; } } else Rfu.RfuFunc = NULL; } bool8 Rfu_SendBlockRequest(u8 blockRequestType) { Rfu.cmdA100_blockRequestType = blockRequestType; RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ); return TRUE; } static void OnDisconnect_PowerDownRfu(void) { rfu_clearAllSlot(); rfu_LMAN_powerDownRFU(); gReceivedRemoteLinkPlayers = FALSE; Rfu.isShuttingDown = TRUE; Rfu.RfuFunc = NULL; } static void DisconnectRfu(void) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); OnDisconnect_PowerDownRfu(); } static void TryDisconnectRfu(void) { if (Rfu.parent_child == MODE_CHILD) { rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 2; } else Rfu.RfuFunc = DisconnectRfu; } void LinkRfu_FatalError(void) { rfu_LMAN_requestChangeAgbClockMaster(); Rfu.unk_ce4 = 1; Rfu.bm_DisconnectSlot = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; } // RFU equivalent of LinkCB_WaitCloseLink static void WaitAllReadyToCloseLink(void) { s32 i; u8 playerCount = Rfu.playerCount; s32 count = 0; for (i = 0; i < MAX_RFU_PLAYERS; i++) { if (Rfu.readyCloseLink[i]) count++; } if (count == playerCount) { gBattleTypeFlags &= ~(BATTLE_TYPE_LINK_ESTABLISHED | 0xFFFF0000); if (Rfu.parent_child == MODE_CHILD) { Rfu.errorState = 3; TryDisconnectRfu(); } else Rfu.RfuFunc = TryDisconnectRfu; } } static void SendReadyCloseLink(void) { if (IsSendCmdComplete() && !Rfu.foundNewLeaderMaybe) { RfuPrepareSendBuffer(RFUCMD_READY_CLOSE_LINK); Rfu.RfuFunc = WaitAllReadyToCloseLink; } } static void Task_TryReadyCloseLink(u8 taskId) { if (Rfu.RfuFunc == NULL) { Rfu.linkClosing = TRUE; Rfu.RfuFunc = SendReadyCloseLink; DestroyTask(taskId); } } void Rfu_SetCloseLinkCallback(void) { if (!FuncIsActiveTask(Task_TryReadyCloseLink)) CreateTask(Task_TryReadyCloseLink, 5); } static void SendReadyExitStandbyUntilAllReady(void) { u8 playerCount; u8 i; if (GetMultiplayerId() != 0) // child { if (Rfu.recvQueue.count == 0 && Rfu.resendExitStandbyTimer > 60) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); Rfu.resendExitStandbyTimer = 0; } } playerCount = GetLinkPlayerCount(); for (i = 0; i < playerCount; i++) { if (Rfu.readyExitStandby[i] == 0) break; } if (i == playerCount) { for (i = 0; i < MAX_RFU_PLAYERS; i++) Rfu.readyExitStandby[i] = 0; Rfu.resendExitStandbyCount++; Rfu.RfuFunc = NULL; } Rfu.resendExitStandbyTimer++; } static void LinkLeaderReadyToExitStandby(void) { if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); Rfu.RfuFunc = SendReadyExitStandbyUntilAllReady; } } // RFU equivalent of LinkCB_Standby and LinkCB_StandbyForAll static void Rfu_LinkStandby(void) { u8 i; u8 playerCount; if (GetMultiplayerId() != 0) // child { if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); Rfu.RfuFunc = SendReadyExitStandbyUntilAllReady; } } else // parent { playerCount = GetLinkPlayerCount(); for (i = 1; i < playerCount; i++) { if (Rfu.readyExitStandby[i] == 0) break; } if (i == playerCount) { if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); Rfu.RfuFunc = LinkLeaderReadyToExitStandby; } } } } void Rfu_SetLinkStandbyCallback(void) { if (Rfu.RfuFunc == NULL) { Rfu.RfuFunc = Rfu_LinkStandby; Rfu.resendExitStandbyTimer = 0; } } bool32 IsRfuSerialNumberValid(u32 serialNo) { s32 i; for (i = 0; sAcceptedSerialNos[i] != serialNo; i++) { if (sAcceptedSerialNos[i] == 0xFFFF) return FALSE; } return TRUE; } u8 ToggleLMANlinkRecovery(bool32 enable) { if (!enable) return rfu_LMAN_setLinkRecovery(FALSE, 0); rfu_LMAN_setLinkRecovery(TRUE, 600); return 0; } void Rfu_UnionRoomChat_StopLinkManager(void) { Rfu.linkClosing = TRUE; rfu_LMAN_stopManager(FALSE); } u8 LinkRfu_GetMultiplayerId(void) { if (Rfu.parent_child == MODE_PARENT) return 0; return Rfu.multiplayerId; } u8 GetRfuPlayerCount(void) { return Rfu.playerCount; } bool8 IsLinkRfuTaskFinished(void) { return Rfu.RfuFunc != NULL ? FALSE : TRUE; } static void CallRfuFunc(void) { if (Rfu.RfuFunc != NULL) Rfu.RfuFunc(); } static bool8 CheckForLeavingGroupMembers(void) { s32 i; bool8 retval = FALSE; for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.partnerSendStatuses[i] < RFU_STATUS_JOIN_GROUP_OK || Rfu.partnerSendStatuses[i] > RFU_STATUS_JOIN_GROUP_NO) { if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) { if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_LEAVE_GROUP_NOTICE) { Rfu.partnerSendStatuses[i] = RFU_STATUS_LEAVE_GROUP; Rfu.partnerRecvStatuses[i] = RFU_STATUS_10; rfu_clearSlot(TYPE_NI_RECV, i); rfu_NI_setSendData(1 << i, 8, &Rfu.partnerSendStatuses[i], 1); retval = TRUE; } } else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) { rfu_clearSlot(TYPE_NI_RECV, i); } } } return retval; } bool32 sub_80FA5D4(void) { u8 flags = 0; s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_11) { flags |= (1 << i); Rfu.partnerRecvStatuses[i] = RFU_STATUS_OK; } } if (flags) { rfu_REQ_disconnect(flags); rfu_waitREQComplete(); } for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_10 || Rfu.partnerRecvStatuses[i] == RFU_STATUS_11) return TRUE; } return FALSE; } bool32 CheckTrainerHasLeftByIdAndName(u16 trainerId, const u8 *trainerName) { u8 r1 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (r1 == 0xFF) return TRUE; if (Rfu.partnerSendStatuses[r1] == RFU_STATUS_LEAVE_GROUP) return TRUE; return FALSE; } void SendByteToPartnerByIdAndName(u8 value, u16 trainerId, const u8 *trainerName) { u8 slotNo = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); Rfu.partnerSendStatuses[slotNo] = value; rfu_clearSlot(TYPE_NI_SEND, slotNo); rfu_NI_setSendData(1 << slotNo, 8, Rfu.partnerSendStatuses + slotNo, 1); } void SendLeaveGroupNotice(void) { Rfu.sendStatus = RFU_STATUS_LEAVE_GROUP_NOTICE; rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot); rfu_NI_setSendData(1 << Rfu.child_slot, 8, &Rfu.sendStatus, 1); } u32 WaitSendByteToPartnerByIdAndName(u16 trainerId, const u8 *trainerName) { u8 r0 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (r0 == 0xFF) return 2; if (gRfuSlotStatusNI[r0]->send.state == SLOT_STATE_READY) return 1; return 0; } static void UpdateChildStatuses(void) { s32 i; CheckForLeavingGroupMembers(); for (i = 0; i < RFU_CHILD_MAX; i++) { if (gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_FAILED) { if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_10) Rfu.partnerRecvStatuses[i] = RFU_STATUS_11; rfu_clearSlot(TYPE_NI_SEND, i); } } } static s32 GetRfuRecvStatus(void) { s32 retval = RFU_STATUS_OK; if (Rfu.sendStatus == RFU_STATUS_LEAVE_GROUP_NOTICE) { 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.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.child_slot); RfuSetStatus(Rfu.recvStatus, 0); retval = Rfu.recvStatus; } else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) { rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot); retval = RFU_STATUS_JOIN_GROUP_NO; } return retval; } static void sub_80FA834(u8 taskId) { s32 i; if (Rfu.status == RFU_STATUS_FATAL_ERROR || Rfu.status == RFU_STATUS_CONNECTION_ERROR) { Rfu.foundNewLeaderMaybe = FALSE; DestroyTask(taskId); } switch (gTasks[taskId].data[0]) { case 0: if (AreNoPlayersReceiving()) { ResetBlockReceivedFlags(); LocalLinkPlayerToBlock(); gTasks[taskId].data[0]++; } break; case 1: if (Rfu.parent_child == MODE_PARENT) { if (gReceivedRemoteLinkPlayers) RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST_2); else RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST); gTasks[taskId].data[0] = 101; } else gTasks[taskId].data[0] = 2; break; case 101: if (IsSendCmdComplete()) gTasks[taskId].data[0] = 2; break; case 2: if (Rfu.playerCount) gTasks[taskId].data[0]++; break; case 3: if (Rfu.parent_child == MODE_PARENT) { if (AreNoPlayersReceiving()) { Rfu.cmdA100_blockRequestType = 0; RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ); gTasks[taskId].data[0]++; } } else gTasks[taskId].data[0]++; break; case 4: if (AreAllPlayersFinishedReceiving()) gTasks[taskId].data[0]++; break; case 5: for (i = 0; i < Rfu.playerCount; i++) { LinkPlayerFromBlock(i); Rfu_ResetBlockReceivedFlag(i); } gTasks[taskId].data[0]++; break; case 6: DestroyTask(taskId); gReceivedRemoteLinkPlayers = TRUE; Rfu.foundNewLeaderMaybe = FALSE; rfu_LMAN_setLinkRecovery(1, 600); if (Rfu.unionRoomChatters) { for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.unionRoomChatters >> i) & 1) { Rfu.bmChatLeaderMaybe = 1 << i; Rfu.unionRoomChatters ^= (1 << i); } } } break; } } static void ClearSelectedLinkPlayerIds(u16 disconnectMask) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if ((disconnectMask >> i) & 1) Rfu.linkPlayerIdx[i] = 0; } } static void ReceiveRfuLinkPlayers(const struct SioInfo *chunk) { s32 i; Rfu.playerCount = chunk->playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) Rfu.linkPlayerIdx[i] = chunk->linkPlayerIdx[i]; for (i = 0; i < MAX_RFU_PLAYERS; i++) { gLinkPlayers[i] = chunk->linkPlayers[i]; ConvertLinkPlayerName(gLinkPlayers + i); } } static void ValidateAndReceivePokemonSioInfo(void *recvBuffer) { if (strcmp("PokemonSioInfo", recvBuffer) == 0) { ReceiveRfuLinkPlayers(recvBuffer); CpuFill16(0, recvBuffer, sizeof(struct SioInfo)); ResetBlockReceivedFlag(0); } } static void Task_ExchangeLinkPlayers(u8 taskId) { s32 i; struct LinkPlayerBlock *r2; struct SioInfo *r5; u8 r4 = Rfu.linkPlayerIdx[gUnknown_843EC38[Rfu.unk_ce9]]; if (Rfu.status == 1 || Rfu.status == 2) { Rfu.foundNewLeaderMaybe = FALSE; DestroyTask(taskId); } switch (gTasks[taskId].data[0]) { case 0: if (IsSendCmdComplete()) { ResetBlockReceivedFlag(r4); RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST_2); gTasks[taskId].data[0]++; } break; case 1: if (IsSendCmdComplete()) gTasks[taskId].data[0]++; break; case 2: if ((GetBlockReceivedStatus() >> r4) & 1) { ResetBlockReceivedFlag(r4); r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4]; gLinkPlayers[r4] = r2->linkPlayer; ConvertLinkPlayerName(gLinkPlayers + r4); gTasks[taskId].data[0]++; } break; case 3: // 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->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i]; memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); gTasks[taskId].data[0]++; // fallthrough case 4: r5 = (struct SioInfo *)gBlockSendBuffer; r5->playerCount = Rfu.playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) 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 SioInfo)); ResetBlockReceivedFlag(0); Rfu.foundNewLeaderMaybe = FALSE; if (Rfu.unionRoomChatters) { for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.unionRoomChatters >> i) & 1) { Rfu.bmChatLeaderMaybe = 1 << i; Rfu.unionRoomChatters ^= (1 << i); Rfu.foundNewLeaderMaybe = TRUE; break; } } } DestroyTask(taskId); } break; } } static void sub_80FACF0(u8 taskId) { if (Rfu.status == RFU_STATUS_FATAL_ERROR || Rfu.status == RFU_STATUS_CONNECTION_ERROR) DestroyTask(taskId); switch (gTasks[taskId].data[0]) { case 0: if (Rfu.playerCount != 0) { LocalLinkPlayerToBlock(); SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock)); gTasks[taskId].data[0]++; } break; case 1: if (IsLinkTaskFinished()) gTasks[taskId].data[0]++; break; case 2: if (GetBlockReceivedStatus() & 1) { ReceiveRfuLinkPlayers((const struct SioInfo *)gBlockRecvBuffer); ResetBlockReceivedFlag(0); gReceivedRemoteLinkPlayers = TRUE; DestroyTask(taskId); } break; } } static void RfuCheckErrorStatus(void) { 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; SetLinkErrorFromRfu( (Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.recvQueue.count, Rfu.sendQueue.count, RfuGetStatus() == RFU_STATUS_CONNECTION_ERROR ); Rfu.errorState = 2; CloseLink(); } else if (Rfu.sendQueue.full == TRUE || Rfu.recvQueue.full == TRUE) { if (lman.childClockSlave_flag) rfu_LMAN_requestChangeAgbClockMaster(); RfuSetStatus(RFU_STATUS_FATAL_ERROR, 0x7000); GetLinkmanErrorParams(0x7000); } } static void rfu_REQ_recvData_then_sendData(void) { if (lman.parent_child == MODE_PARENT) { rfu_REQ_recvData(); rfu_waitREQComplete(); rfu_LMAN_REQ_sendData(RFU_CHILD_CLOCK_SLAVE_OFF); } } bool32 LinkRfuMain1(void) { bool32 retval = FALSE; Rfu.parentId = 0; rfu_LMAN_manager_entity(Random()); if (!Rfu.isShuttingDown) { switch (Rfu.parent_child) { case MODE_PARENT: sub_80F911C(); break; case MODE_CHILD: retval = RfuProcessEnqueuedRecvBlock(); break; case MODE_P_C_SWITCH: rfu_REQ_recvData_then_sendData(); break; } } return retval; } bool32 LinkRfuMain2(void) { bool32 retval = FALSE; if (!Rfu.isShuttingDown) { if (Rfu.parent_child == MODE_PARENT) retval = sub_80F9204(); RfuCheckErrorStatus(); } return retval; } static void CopyPlayerNameToUnameBuffer(void) { StringCopy(gHostRFUtgtUnameBuffer, gSaveBlock2Ptr->playerName); } void ClearAndInitHostRFUtgtGname(void) { memset(&gHostRFUtgtGnameBuffer, 0, RFU_GAME_NAME_LENGTH); InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, ACTIVITY_NONE, FALSE, 0); } void SetHostRFUtgtGname(u8 activity, u32 child_sprite_genders, u32 started) { InitHostRFUtgtGname(&gHostRFUtgtGnameBuffer, activity, started, child_sprite_genders); } void SetGnameBufferWonderFlags(bool32 hasNews, bool32 hasCard) { gHostRFUtgtGnameBuffer.unk_00.hasNews = hasNews; gHostRFUtgtGnameBuffer.unk_00.hasCard = hasCard; } void RfuUpdatePlayerGnameStateAndSend(u32 type, u32 species, u32 level) { gHostRFUtgtGnameBuffer.type = type; gHostRFUtgtGnameBuffer.species = species; gHostRFUtgtGnameBuffer.level = level; } void UpdateGameData_GroupLockedIn(bool8 started) { gHostRFUtgtGnameBuffer.started = started; rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); } void UpdateGameDataWithActivitySpriteGendersFlag(u8 activity, u32 child_sprite_genders, u32 started) { if (activity) SetHostRFUtgtGname(activity, child_sprite_genders, started); rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRFUtgtGnameBuffer, gHostRFUtgtUnameBuffer); } void sub_80FB030(u32 linkPlayerCount) { s32 i; u32 numConnectedChildren; u32 child_sprite_genders; s32 bm_child_slots; if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { numConnectedChildren = 0; child_sprite_genders = 0; bm_child_slots = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; for (i = 0; i < RFU_CHILD_MAX; i++) { if ((bm_child_slots >> i) & 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; } } UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, child_sprite_genders, 0); } } static void GetLinkmanErrorParams(u32 msg) { if (Rfu.errorState == 0) { Rfu.linkman_param[0] = lman.param[0]; Rfu.linkman_param[1] = lman.param[1]; Rfu.linkman_msg = msg; Rfu.errorState = 1; } } static void ResetErrorState(void) { Rfu.errorState = 0; } void sub_80FB128(bool32 a0) { if (!a0) Rfu.errorState = 0; else Rfu.errorState = 4; } static void sub_80FB154(void) { sub_80FBE20(lman.acceptSlot_flag, 1); Rfu.RfuFunc = NULL; } static void sub_80FB174(void) { Rfu.RfuFunc = sub_80FB154; } static void LmanCallback_Parent2(u8 msg, u8 param_count) { u8 i; u8 bmDisconnectFlag = 0; switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: Rfu.state = 2; break; case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: break; case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: sub_80FB564(lman.param[0]); for (i = 0; i < RFU_CHILD_MAX; i++) { if ((lman.param[0] >> i) & 1) { struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; if (structPtr->activity == GetHostRFUtgtGname()->activity) { Rfu.partnerSendStatuses[i] = RFU_STATUS_OK; Rfu.partnerRecvStatuses[i] = RFU_STATUS_OK; rfu_setRecvBuffer(TYPE_NI, i, Rfu.partnerRecvStatuses + i, 1); } else { bmDisconnectFlag |= (1 << i); } } } if (bmDisconnectFlag) { rfu_REQ_disconnect(bmDisconnectFlag); rfu_waitREQComplete(); } break; case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED: break; case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; case LMAN_MSG_END_WAIT_CHILD_NAME: if (Rfu.acceptSlot_flag != lman.acceptSlot_flag) { rfu_REQ_disconnect(Rfu.acceptSlot_flag ^ lman.acceptSlot_flag); rfu_waitREQComplete(); } Rfu.state = 17; break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: Rfu.linkLossRecoveryState = 1; break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: Rfu.linkLossRecoveryState = 3; break; 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.bm_PartnerFlags == 0) GetLinkmanErrorParams(msg); else sub_80FB174(); } RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case 0x34: break; case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); GetLinkmanErrorParams(msg); Rfu.isShuttingDown = TRUE; break; 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); RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); Rfu.unk_cdb = TRUE; break; } } static const u8 unref_843EDF3[] = _("　あきと"); static void LmanCallback_Child(u8 msg, u8 param_count) { switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: Rfu.state = 6; break; case LMAN_MSG_PARENT_FOUND: Rfu.parentId = lman.param[0]; break; case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; case LMAN_MSG_CONNECT_PARENT_SUCCESSED: Rfu.child_slot = lman.param[0]; break; case LMAN_MSG_CONNECT_PARENT_FAILED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: Rfu.state = 11; Rfu.sendStatus = RFU_STATUS_OK; Rfu.recvStatus = RFU_STATUS_OK; rfu_setRecvBuffer(TYPE_NI, Rfu.child_slot, &Rfu.recvStatus, 1); rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); break; case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: Rfu.linkLossRecoveryState = 2; if (Rfu.recvStatus == RFU_STATUS_JOIN_GROUP_NO) break; case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: if (Rfu.linkLossRecoveryState != 2) Rfu.linkLossRecoveryState = 4; if (Rfu.recvStatus != RFU_STATUS_LEAVE_GROUP) RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); Debug_PrintString("LINK LOSS DISCONNECT!", 5, 5); if (gReceivedRemoteLinkPlayers == 1) GetLinkmanErrorParams(msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: Rfu.linkLossRecoveryState = 1; Debug_PrintString("LINK LOSS RECOVERY NOW", 5, 5); break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: Rfu.linkLossRecoveryState = 3; Rfu.linkRecovered = 1; break; case 0x34: break; case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); GetLinkmanErrorParams(msg); Rfu.isShuttingDown = TRUE; break; 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: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); GetLinkmanErrorParams(msg); Rfu.unk_cdb = TRUE; break; } } static void sub_80FB564(s32 bmConnectedFlag) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if ((bmConnectedFlag >> i) & 1) { Rfu.unk_cea[i] = 0; Rfu.unk_cee[i] = 0xFF; } } } static u8 GetNewChildrenInUnionRoomChat(s32 bmNewChildSlot) { u8 ret = 0; u8 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if ((bmNewChildSlot >> i) & 1) { struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; if (structPtr->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) ret |= (1 << i); } } return ret; } static void LmanCallback_Parent(u8 msg, u8 param_count) { u8 r1; switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: Rfu.state = 17; break; case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: RfuSetStatus(RFU_STATUS_NEW_CHILD_DETECTED, 0); break; case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && !Rfu.linkClosing) { u8 bmAcceptSlot = GetNewChildrenInUnionRoomChat(lman.param[0]); if (bmAcceptSlot != 0) { r1 = 1 << CountTrailingZeroes(bmAcceptSlot); if (Rfu.unionRoomChatters == 0 && !Rfu.foundNewLeaderMaybe) { Rfu.bmChatLeaderMaybe = r1; Rfu.unionRoomChatters |= (r1 ^ bmAcceptSlot); Rfu.foundNewLeaderMaybe = TRUE; } else { Rfu.unionRoomChatters |= bmAcceptSlot; } } if (bmAcceptSlot != lman.param[0]) { Rfu.bm_DisconnectSlot |= (bmAcceptSlot ^ lman.param[0]); Rfu.unk_ce4 = 2; } } else if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM)) { rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); } sub_80FB564(lman.param[0]); break; case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED: break; case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; case LMAN_MSG_END_WAIT_CHILD_NAME: if (GetHostRFUtgtGname()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1) { r1 = 1 << CountTrailingZeroes(lman.param[0]); rfu_REQ_disconnect(lman.acceptSlot_flag ^ r1); rfu_waitREQComplete(); } if (Rfu.state == 15) Rfu.state = 16; break; case LMAN_MSG_PARENT_FOUND: Rfu.parentId = lman.param[0]; break; case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; case LMAN_MSG_CONNECT_PARENT_SUCCESSED: Rfu.child_slot = lman.param[0]; break; case LMAN_MSG_CONNECT_PARENT_FAILED: Rfu.state = 18; if (Rfu.unk_ccf < 2) { Rfu.unk_ccf++; CreateTask(sub_80FC028, 2); } else { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); } break; case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: Rfu.state = 13; RfuSetStatus(RFU_STATUS_CHILD_SEND_COMPLETE, 0); rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); break; case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: if (lman.acceptSlot_flag & lman.param[0]) Rfu.linkLossRecoveryState = 1; break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: Rfu.linkLossRecoveryState = 3; if (gRfuLinkStatus->parentChild == MODE_CHILD) Rfu.linkRecovered = 1; break; 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.bm_PartnerFlags &= ~(lman.param[0]); if (Rfu.bm_PartnerFlags == 0) GetLinkmanErrorParams(msg); else sub_80FB174(); } } else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1) { GetLinkmanErrorParams(msg); rfu_LMAN_stopManager(0); } if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && lman.pcswitch_flag == 0 && FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) Rfu.state = 17; RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_DISCONNECTED_BY_USER: Rfu.bm_DisconnectSlot = 0; break; case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); GetLinkmanErrorParams(msg); Rfu.isShuttingDown = TRUE; break; 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); RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); Rfu.unk_cdb = FALSE; break; } } void sub_80FB9D0(void) { Rfu.unk_ce4 = 2; } void RfuSetStatus(u8 status, u16 msg) { Rfu.status = status; Rfu.linkman_msg = msg; } u8 RfuGetStatus(void) { return Rfu.status; } bool32 RfuHasErrored(void) { u32 status = RfuGetStatus(); if (status == RFU_STATUS_FATAL_ERROR || status == RFU_STATUS_CONNECTION_ERROR) return TRUE; else return FALSE; } bool32 RfuHasFoundNewLeader(void) { return Rfu.foundNewLeaderMaybe; } bool8 Rfu_IsMaster(void) { return Rfu.parent_child; } void RFUVSync(void) { rfu_LMAN_syncVBlank(); } void ClearRecvCommands(void) { CpuFill32(0, gRecvCmds, sizeof(gRecvCmds)); } static void sub_80FBA64(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } static void sub_80FBA78(void) { s32 i; ResetSpriteData(); FreeAllSpritePalettes(); ResetTasks(); ResetPaletteFade(); SetVBlankCallback(sub_80FBA64); if (IsWirelessAdapterConnected()) { gLinkType = LINKTYPE_TRADE; SetWirelessCommType1(); OpenLink(); SeedRng(gMain.vblankCounter2); for (i = 0; i < RFU_CHILD_MAX; i++) gSaveBlock2Ptr->playerTrainerId[i] = Random() % 256; SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG2_ON | DISPCNT_OBJ_1D_MAP); RunTasks(); AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); LinkRfu_CreateIdleTask(); SetMainCallback2(sub_80FBB74); } } bool32 IsUnionRoomListenTaskActive(void) { return FuncIsActiveTask(Task_LinkRfu_UnionRoomListen); } void LinkRfu_CreateIdleTask(void) { if (!FuncIsActiveTask(Task_idle)) Rfu.idleTaskId = CreateTask(Task_idle, 0); } void LinkRfu_DestroyIdleTask(void) { if (FuncIsActiveTask(Task_idle) == TRUE) DestroyTask(Rfu.idleTaskId); } static void sub_80FBB74(void) { RunTasks(); AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); } void InitializeRfuLinkManager_LinkLeader(u32 availSlots) { Rfu.parent_child = MODE_PARENT; CopyPlayerNameToUnameBuffer(); rfu_LMAN_initializeManager(LmanCallback_Parent2, NULL); sRfuReqConfig = sRfuReqConfigTemplate; sRfuReqConfig.availSlot_flag = sAvailSlots[availSlots - 1]; CreateTask_LinkLeaderSearchForChildren(); } void InitializeRfuLinkManager_JoinGroup(void) { Rfu.parent_child = MODE_CHILD; CopyPlayerNameToUnameBuffer(); rfu_LMAN_initializeManager(LmanCallback_Child, MscCallback_Child); CreateTask_JoinGroupSearchForParent(); } void InitializeRfuLinkManager_EnterUnionRoom(void) { if (QL_IS_PLAYBACK_STATE) return; Rfu.parent_child = 2; CopyPlayerNameToUnameBuffer(); rfu_LMAN_initializeManager(LmanCallback_Parent, NULL); sRfuReqConfig = sRfuReqConfigTemplate; sRfuReqConfig.linkRecovery_enable = 0; sRfuReqConfig.linkRecovery_period = 600; Rfu.searchTaskId = CreateTask(Task_LinkRfu_UnionRoomListen, 1); } static u16 ReadU16(const void *ptr) { const u8 *ptr_ = ptr; return (ptr_[1] << 8) | (ptr_[0]); } /* * ================================================================ * 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 partnerTrainerId = ReadU16(((struct GFtgtGname *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId); if (IsRfuSerialNumberValid(gRfuLinkStatus->partner[i].serialNo) && !StringCompare(trainerName, gRfuLinkStatus->partner[i].uname) && trainerId == partnerTrainerId) { ret = i; if (gRfuLinkStatus->partner[i].slot != 0xFF) break; } } return ret; } static void RfuReqDisconnectSlot(u32 bmDisconnectSlot) { rfu_REQ_disconnect(bmDisconnectSlot); rfu_waitREQComplete(); Rfu.bm_PartnerFlags &= ~(bmDisconnectSlot); rfu_clearSlot(TYPE_UNI_SEND, Rfu.unk_cda); rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, 70); Rfu.unk_cda = CountTrailingZeroes(Rfu.bm_PartnerFlags); } void RequestDisconnectSlotByTrainerNameAndId(const u8 *trainerName, u16 trainerId) { u8 var = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); if (var != 0xFF) RfuReqDisconnectSlot(1 << var); } void sub_80FBD6C(u32 a0) { if (a0 != 0) { s32 i; u8 var = 0; for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.linkPlayerIdx[i] == a0 && (Rfu.bm_PartnerFlags >> i) & 1) var |= 1 << i; } if (var) sub_80FBE20(var, 2); } } static void sub_80FBDB8(u8 taskId) { if (IsSendCmdComplete() && !Rfu.foundNewLeaderMaybe) { RfuPrepareSendBuffer(RFUCMD_PARENT_DISCONNECT); gSendCmd[1] = gTasks[taskId].data[0]; gSendCmd[2] = gTasks[taskId].data[1]; Rfu.playerCount -= sNumSetBits[gTasks[taskId].data[0]]; gSendCmd[3] = Rfu.playerCount; DestroyTask(taskId); } } static void sub_80FBE20(u32 a0, u32 a1) { u8 taskId = FindTaskIdByFunc(sub_80FBDB8); if (taskId == 0xFF) { taskId = CreateTask(sub_80FBDB8, 5); gTasks[taskId].data[0] = a0; } else { gTasks[taskId].data[0] |= a0; } gTasks[taskId].data[1] = a1; } static void Task_RfuReconnectWithParent(u8 taskId) { s16 *data = gTasks[taskId].data; if (ContactedByParentAttemptingToReconnect()) { u8 id = GetPartnerIndexByNameAndTrainerID((u8*)data, ReadU16(&data[8])); if (id != 0xFF) { if (gRfuLinkStatus->partner[id].slot != 0xFF) { Rfu.reconnectedParentIdx = id; if (IsParentSuccessfullyReconnected()) DestroyTask(taskId); } else if (GetHostRFUtgtGname()->activity == ACTIVITY_WCARD2 || GetHostRFUtgtGname()->activity == ACTIVITY_WNEWS2) { data[15]++; } else { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); DestroyTask(taskId); } } else { data[15]++; Rfu.reconnectedParentIdx = id; } } else { data[15]++; } if (data[15] > 240) { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); DestroyTask(taskId); } } void CreateTask_RfuReconnectWithParent(const u8 *trainerName, u16 trainerId) { u8 taskId; s16 *data; Rfu.status = RFU_STATUS_OK; taskId = CreateTask(Task_RfuReconnectWithParent, 3); data = gTasks[taskId].data; StringCopy((u8*)(data), trainerName); data[8] = trainerId; } static bool32 ShouldRejectPartnerConnectionBasedOnActivity(s16 activity, struct GFtgtGname *partnerGname) { if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { if (partnerGname->activity != (ACTIVITY_CHAT | IN_UNION_ROOM)) return TRUE; } else if (partnerGname->activity != IN_UNION_ROOM) { return TRUE; } else if (activity == (ACTIVITY_TRADE | IN_UNION_ROOM)) { struct GFtgtGname *myTradeGname = (struct GFtgtGname *)&Rfu.tgtData.gname; if (myTradeGname->species == SPECIES_EGG) { if (partnerGname->species == myTradeGname->species) return FALSE; else return TRUE; } else if (partnerGname->species != myTradeGname->species || partnerGname->level != myTradeGname->level || partnerGname->type != myTradeGname->type) { return TRUE; } } return FALSE; } static void sub_80FC028(u8 taskId) { if (Rfu.status == RFU_STATUS_NEW_CHILD_DETECTED) DestroyTask(taskId); if (++gTasks[taskId].data[0] > 300) { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); DestroyTask(taskId); } if (Rfu.parentId != 0 && lman.parent_child == MODE_CHILD) { u16 trainerId = ReadU16(((struct GFtgtGname *)&Rfu.tgtData.gname)->unk_00.playerTrainerId); u8 id = GetPartnerIndexByNameAndTrainerID(Rfu.tgtData.uname, trainerId); if (id != 0xFF) { if (!ShouldRejectPartnerConnectionBasedOnActivity(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname)) { if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 90)) { Rfu.state = 10; DestroyTask(taskId); } } else { RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); DestroyTask(taskId); } } } } void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 activity) { u8 taskId, taskId2; Rfu.unk_ccf = 0; Rfu.status = RFU_STATUS_OK; StringCopy(Rfu.tgtData.uname, name); memcpy(Rfu.tgtData.gname, structPtr, RFU_GAME_NAME_LENGTH); rfu_LMAN_forceChangeSP(); taskId = CreateTask(sub_80FC028, 2); 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; } else { if (taskId2 != 0xFF) gTasks[taskId2].data[7] = 0; } } bool8 IsRfuRecoveringFromLinkLoss(void) { if (Rfu.linkLossRecoveryState == 1) return TRUE; else return FALSE; } bool32 sub_80FC1CC(void) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { if ((lman.acceptSlot_flag >> i) & 1 && Rfu.partnerSendStatuses[i] == 0) return FALSE; } return TRUE; } static void Debug_PrintEmpty(void) { s32 i; for (i = 0; i < 20; i++) Debug_PrintString(" ", 0, i); } static const char gUnknown_843EE47[16] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0' }; static const char gUnknown_843EE57[9] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0' }; static const char gUnknown_843EE60[] = {' ', '\0'}; static const char gUnknown_843EE62[] = {'*', '\0'}; static void Debug_PrintStatus(void) { s32 i, j; Debug_PrintNum(GetBlockReceivedStatus(), 0x1C, 0x13, 2); Debug_PrintNum(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1); Debug_PrintNum(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1); if (Rfu.parent_child == MODE_PARENT) { for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gRfuLinkStatus->getNameFlag >> i) & 1) { Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); Debug_PrintString((void *) &gRfuLinkStatus->partner[i].gname, 6, i + 3); Debug_PrintString(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } for (i = 0; i < RFU_CHILD_MAX; i++) { for (j = 0; j < 14; j++) { Debug_PrintNum(Rfu.main_UNI_recvBuffer[i][j], j * 2, i + 11, 2); } } Debug_PrintString("NOWSLOT", 1, 0xF); } else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0) { for (i = 0; i < RFU_CHILD_MAX; i++) { Debug_PrintNum(0, 1, i + 3, 4); Debug_PrintString(gUnknown_843EE47, 6, i + 3); Debug_PrintString(gUnknown_843EE57, 0x16, i + 3); } Debug_PrintNum(gRfuLinkStatus->partner[Rfu.child_slot].serialNo, 1, 3, 4); Debug_PrintString(gRfuLinkStatus->partner[Rfu.child_slot].gname, 6, 3); Debug_PrintString(gRfuLinkStatus->partner[Rfu.child_slot].uname, 0x16, 3); } else { for (i = 0; i < gRfuLinkStatus->findParentCount; i++) { if (gRfuLinkStatus->partner[i].slot != 0xFF) { Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); Debug_PrintNum(gRfuLinkStatus->partner[i].id, 6, i + 3, 4); Debug_PrintString(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } for (; i < RFU_CHILD_MAX; i++) { Debug_PrintNum(0, 1, i + 3, 4); Debug_PrintString(gUnknown_843EE47, 6, i + 3); Debug_PrintString(gUnknown_843EE57, 0x16, i + 3); } } } static const char gUnknown_843EE6C[][12] = { " ", "CLOCK DRIFT", "BUSY SEND ", "CMD REJECT ", "CLOCK SLAVE" }; static const char gUnknown_843EEA8[][8] = { "CHILD ", "PARENT", "SEARCH" }; static u32 GetRfuSendQueueLength(void) { return Rfu.sendQueue.count; } u32 GetRfuRecvQueueLength(void) { return Rfu.recvQueue.count; } static void Task_idle(u8 taskId) { }