diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/librfu_rfu.c | 10 | ||||
| -rw-r--r-- | src/link.c | 2 | ||||
| -rw-r--r-- | src/link_rfu.c | 1381 | ||||
| -rw-r--r-- | src/link_rfu_2.c | 2834 | ||||
| -rw-r--r-- | src/link_rfu_3.c | 948 | ||||
| -rw-r--r-- | src/mevent_server_helpers.c | 8 | ||||
| -rw-r--r-- | src/party_menu.c | 4 | ||||
| -rw-r--r-- | src/trade.c | 4 |
8 files changed, 5177 insertions, 14 deletions
diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 96de99c2a..dccd342f2 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1533,11 +1533,11 @@ void rfu_UNI_clearRecvNewDataFlag(u8 slotStatusIndex) gRfuSlotStatusUNI[slotStatusIndex]->recv.newDataFlag = 0; } -void rfu_REQ_sendData(u8 clockChangeFlag) +void rfu_REQ_sendData(bool8 clockChangeFlag) { if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) { - if (gRfuLinkStatus->parentChild == 1 + if (gRfuLinkStatus->parentChild == MODE_PARENT && !(gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag)) { if (gRfuStatic->commExistFlag) @@ -1555,7 +1555,7 @@ void rfu_REQ_sendData(u8 clockChangeFlag) gRfuFixed->LLFBuffer[0] = 1; gRfuFixed->LLFBuffer[4] = 0xFF; STWI_set_Callback_M(rfu_CB_sendData3); - if (clockChangeFlag == 0) + if (!clockChangeFlag) STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, 1); else STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, 1); @@ -1569,7 +1569,7 @@ void rfu_REQ_sendData(u8 clockChangeFlag) if (gRfuLinkStatus->LLFReadyFlag) { STWI_set_Callback_M(rfu_CB_sendData); - if (clockChangeFlag != 0) + if (clockChangeFlag) { STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); return; @@ -1577,7 +1577,7 @@ void rfu_REQ_sendData(u8 clockChangeFlag) STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); } } - if (clockChangeFlag != 0) + if (clockChangeFlag) { if (gRfuLinkStatus->parentChild == MODE_PARENT) { diff --git a/src/link.c b/src/link.c index 58207dee6..dbaa25782 100644 --- a/src/link.c +++ b/src/link.c @@ -984,7 +984,7 @@ u8 GetMultiplayerId(void) { if (gWirelessCommType == 1) { - return rfu_get_multiplayer_id(); + return LinkRfu_GetMultiplayerId(); } return SIO_MULTI_CNT->id; } diff --git a/src/link_rfu.c b/src/link_rfu.c new file mode 100644 index 000000000..0d6e14551 --- /dev/null +++ b/src/link_rfu.c @@ -0,0 +1,1381 @@ +#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 == 0x8001) + 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()) + { + 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()) + { + 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() == 0x8001 ? 0x44 : 0xFF; + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + sub_80FE7F0(r2, 0); + break; + case 1: + if (sub_80FD3A4() == 0x8001) + { + 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->unk_02, gUnknown_3005E10.unk_3c->unk_00, gUnknown_3005E10.unk_3c->unk_01); + break; + case 4: + rfu_REQ_configGameData(gUnknown_3005E10.unk_3c->unk_04, gUnknown_3005E10.unk_3c->unk_06, (const u8 *)gUnknown_3005E10.unk_3c->unk_08, gUnknown_3005E10.unk_3c->unk_0c); + 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 r8, u16 r6) +{ + u8 sp0; + register u8 *stwiRecvBuffer asm("r0"); + u8 *tmp; + u8 i; + + if (gUnknown_3005E10.unk_0e != 0) + { + gUnknown_3005E10.unk_0e = 0; + switch (r8) + { + case 16: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; + gUnknown_3005E10.unk_05 = 4; + } + break; + case 23: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05; + gUnknown_3005E10.unk_05 = 0; + } + break; + case 22: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + sub_80FE7F0(0x00, 0x00); + } + break; + case 25: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 6; + } + break; + case 26: + if (gUnknown_3005E10.unk_1a && --gUnknown_3005E10.unk_1a == 0) + { + gUnknown_3005E10.unk_04 = 7; + gUnknown_3005E10.unk_05 = 8; + } + break; + case 27: + if (r6 == 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 28: + if (r6 == 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 29: + if (r6 == 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 30: + if (r6 == 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 31: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 13; + } + break; + case 32: + if (r6 == 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 33: + if (r6 == 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 50: + if (r6 == 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 51: + if (r6 == 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 52: + if (r6 == 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 39: + if (r6 == 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(4, 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 61: + if (r6 == 0) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + sub_80FE7F0(0x42, 0x00); + } + break; + } + gUnknown_3005E10.unk_0e = 1; + } + else if (r6 == 3 && gUnknown_3005E10.unk_0f && (r8 == 0x24 || r8 == 0x26 || r8 == 0x27)) + { + 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); + r6 = 0; + } + } + switch (r8) + { + case 48: + if (r6 == 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 38: + sub_80FE6F0(); + if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) + { + sub_80FE7F0(0x50, 0x00); + } + break; + case 16: + case 61: + if (r6 == 0) + { + gUnknown_3005E10.unk_0d = 0; + gUnknown_3005E10.unk_01 = 0; + gUnknown_3005E10.unk_00 = 0;; + gUnknown_3005E10.unk_06 = -1; + sub_80FEAF4(); + if (r8 == 61) + { + sub_80FD484(); + } + } + break; + } + if (r6 != 0) + { + if (r8 == 28 && r6 != 0 && gUnknown_3005E10.unk_07 == 4) + { + gRfuLinkStatus->parentChild = MODE_PARENT; + gRfuLinkStatus->connSlotFlag = 0xF; + sub_80FE818(15); + rfu_waitREQComplete(); + return; + } + else + { + gUnknown_3005E10.unk_14 = r8; + gUnknown_3005E10.unk_16 = r6; + if (gUnknown_3005E10.unk_0e) + { + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + } + sub_80FE7F0(0xf0, 0x02); + sub_80FEAF4(); + } + } + if (r8 == 0xFF) + { + 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(0x08, 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(4, 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(4, 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(0x20, 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(0x20, 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 new file mode 100644 index 000000000..88ccf988b --- /dev/null +++ b/src/link_rfu_2.c @@ -0,0 +1,2834 @@ +#include "global.h" +#include "battle.h" +#include "gpu_regs.h" +#include "librfu.h" +#include "link.h" +#include "link_rfu.h" +#include "mystery_gift_menu.h" +#include "overworld.h" +#include "palette.h" +#include "quest_log.h" +#include "random.h" +#include "string_util.h" +#include "task.h" +#include "constants/species.h" + +struct UnkRfuStruct_8010A14{ + char unk_00[15]; // PokemonSioInfo + u8 unk_0f; + u8 unk_10[4]; + struct LinkPlayer unk_14[5]; + u8 fill_a0[0x5c]; +}; + +static EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_203ABF0 = {}; +static EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; + +static struct RfuAPIBuffer gRfuAPIBuffer; +static u8 gUnknown_3001FF8[14]; +static u16 gUnknown_3002008[7]; + +struct GFtgtGname gUnknown_3005440; +struct UnkRfuStruct_2 Rfu; +u8 gUnknown_3005E00[PLAYER_NAME_LENGTH]; + +static void sub_80F8AA4(void); +static void sub_80F8AEC(void); +static void sub_80F8D20(u16 a0); +static void sub_80F8DA8(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 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 sub_80FACF0(u8 taskId); +static void sub_80FB0E8(u32 a0); +static void sub_80FB564(s32 a0); +static void sub_80FBB74(void); +static u8 sub_80FBC70(const u8 *a0, u16 a1); +static void sub_80FBCF8(u32 a0); +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 const struct UnkLinkRfuStruct_02022B2C gUnknown_843EBB4 = { + .unk_00 = 0x04, + .unk_01 = 0x20, + .unk_02 = 0x0000, + .unk_04 = 0x00, + .unk_06 = 0x0002, + .unk_08 = &gUnknown_3005440, + .unk_0c = gUnknown_3005E00, + .unk_10 = 0x01, + .unk_11 = 0x00, + .unk_12 = 0x0258, + .unk_14 = 0x012c +}; + +static const u8 gUnknown_843EBCC[] = { + 0, 3, 2, 1, 0 +}; + +static const u32 gUnknown_843EBD4[] = { + 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 gUnknown_843EC41[] = { + 0, 1, 1, 2, + 1, 2, 2, 3, + 1, 2, 2, 3, + 2, 3, 3, 4 +}; + +static const u8 gUnknown_843EC51[] = { + 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 +}; + +static const struct { + u8 *buffer; + u32 size; +} gUnknown_843EC64[] = { + { gBlockSendBuffer, 200 }, + { gBlockSendBuffer, 200 }, + { gBlockSendBuffer, 100 }, + { gBlockSendBuffer, 220 }, + { gBlockSendBuffer, 40 } +}; + +static const u16 gUnknown_843EC8C[] = { + 0x0002, 0x7f7d, 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, + sub_80FAA94, + sub_80FACF0 +}; + +static void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2) +{ + // debug? +} + +static void nullsub_88(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3) +{ + +} + +void sub_80F85F8(void) +{ + s32 i; + u8 unk_ee_bak = Rfu.unk_ee; + CpuFill16(0, &Rfu, sizeof Rfu); + Rfu.unk_0c = 0xFF; + Rfu.unk_ee = unk_ee_bak; + if (Rfu.unk_ee != 4) + { + Rfu.unk_ee = 0; + } + for (i = 0; i < 5; i++) + { + sub_80F9CB4(Rfu.unk_80 + i); + } + sub_80F9CB4(&Rfu.unk_6c); + sub_80FC478(&Rfu.unk_124); + sub_80FC4D4(&Rfu.unk_9e8); + 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]; + sub_80F86F4(); + rfu_REQ_stopMode(); + rfu_waitREQComplete(); + REG_IME = 0; + gIntrTable[1] = serialIntr; + gIntrTable[2] = timerIntr; + REG_IME = INTR_FLAG_VBLANK; +} + +void sub_80F86F4(void) +{ + if (!rfu_initializeAPI(&gRfuAPIBuffer, sizeof gRfuAPIBuffer, gIntrTable + 1, TRUE)) + { + gLinkType = 0; + sub_80FB128(0); + sub_80F85F8(); + rfu_setTimerInterrupt(3, gIntrTable + 2); + } +} + +static void sub_80F8738(u8 taskId) +{ + sub_80FA738(); + switch (Rfu.unk_04) + { + case 0: + sub_80FD4B0(&gUnknown_203ABF0); + Rfu.unk_04 = 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; + gTasks[taskId].data[1] = 6; + break; + case 3: + break; + case 4: + sub_80FD760(FALSE); + Rfu.unk_04 = 5; + break; + case 5: + break; + case 18: + Rfu.unk_cdb = 0; + sub_80FEA10(sub_80F8DA8); + sub_80F8AA4(); + sub_80F8AEC(); + Rfu.unk_04 = 20; + gTasks[taskId].data[1] = 8; + CreateTask(sub_80FA834, 5); + DestroyTask(taskId); + break; + } +} + +static u8 sub_80F886C(u8 idx) +{ + return gUnknown_843EC51[idx]; +} + +static void sub_80F887C(s32 r2, s32 r5) +{ + u8 i; + u8 r4 = 1; + s32 r1 = r2; + s32 r6 = 0; + if (r5 == -1) + { + for (i = 0; i < RFU_CHILD_MAX; r2 >>= 1, i++) + { + if (r2 & 1) + { + Rfu.unk_cde[i] = r4; + r4++; + } + } + } + else + { + for (i = 0; i < RFU_CHILD_MAX; r1 >>= 1, i++) + { + if (!(r1 & 1)) + { + Rfu.unk_cde[i] = 0; + } + } + for (r4 = 4; r4 != 0; r4--) + { + for (i = 0; i < RFU_CHILD_MAX && Rfu.unk_cde[i] != r4; i++); + if (i == 4) + { + r6 = r4; + } + } + for (r5 &= ~r2, i = 0; i < RFU_CHILD_MAX; r5 >>= 1, i++) + { + if (r5 & 1) + { + Rfu.unk_cde[i] = r6++; + } + } + } +} + +static void sub_80F893C(u8 taskId) +{ + switch (Rfu.unk_04) + { + case 0: + sub_80FD4B0(&gUnknown_843EBB4); + Rfu.unk_04 = 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; + gTasks[taskId].data[1] = 7; + break; + case 7: + break; + case 9: + gTasks[taskId].data[1] = 10; + break; + case 11: + switch (sub_80FA788()) + { + case 5: + Rfu.unk_04 = 12; + break; + case 6: + case 9: + sub_80FEB14(); + Rfu.unk_ce4 = 2; + DestroyTask(taskId); + break; + } + break; + case 12: + { + u8 r5 = 1 << Rfu.unk_c3e; + rfu_clearSlot(12, Rfu.unk_c3e); + rfu_setRecvBuffer(16, Rfu.unk_c3e, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); + rfu_UNI_setSendData(r5, Rfu.unk_4c, sizeof(Rfu.unk_4c)); + gTasks[taskId].data[1] = 8; + DestroyTask(taskId); + if (gUnknown_203AC08.unk_0f == 0) + { + sub_80FC208(); + gUnknown_203AC08.unk_0f++; + } + CreateTask(sub_80FA834, 5); + break; + } + } +} + +static void sub_80F8AA4(void) +{ + u8 i; + u8 r5 = gUnknown_3005E10.unk_00; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (r5 & 1) + { + rfu_setRecvBuffer(16, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i])); + rfu_clearSlot(3, i); + } + r5 >>= 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; +} + +static void sub_80F8B34(u8 taskId) +{ + if (sub_80F9800()->unk_0a_0 == 0x54 && sub_80FB9F4() == 4) + { + rfu_REQ_disconnect(gUnknown_3005E10.unk_00); + rfu_waitREQComplete(); + sub_80FB9E4(0, 0); + } + switch (Rfu.unk_04) + { + case 0: + sub_80FD4B0(&gUnknown_203ABF0); + Rfu.unk_04 = 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; + break; + case 18: + break; + case 13: + if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0) + { + Rfu.unk_0c = 0; + DestroyTask(taskId); + if (gTasks[taskId].data[7]) + { + CreateTask(sub_80FACF0, 1); + } + else + { + CreateTask(sub_80FA834, 5); + } + } + break; + case 14: + sub_80FD760(0); + Rfu.unk_04 = 15; + break; + case 15: + break; + case 16: + Rfu.unk_cdb = 0; + sub_80FEA10(sub_80F8DA8); + sub_80FAFE0(1); + sub_80F8AA4(); + sub_80F8AEC(); + Rfu.unk_04 = 20; + gTasks[taskId].data[1] = 8; + Rfu.unk_0c = 1; + CreateTask(sub_80FA834, 5); + Rfu.unk_ce8 = 1; + DestroyTask(taskId); + break; + } +} + +void sub_80F8CFC(void) +{ + sub_80FD538(1, 0, 240, gUnknown_843EC8C); +} + +void sub_80F8D14(void) +{ + sub_80FD760(FALSE); +} + +static void sub_80F8D20(u16 unused) +{ + s32 i; + + for (i = 0; i < 14; i++) + { + Rfu.unk_4c[i] = 0; + } + rfu_REQ_recvData(); + rfu_waitREQComplete(); + if (gRfuSlotStatusUNI[Rfu.unk_c3e]->recv.newDataFlag) + { + Rfu.unk_cd0++; + sub_80FC588(&Rfu.unk_124, Rfu.unk_c3f); + gUnknown_203AC08.unk_06++; + sub_80F906C(); + rfu_UNI_readySendData(Rfu.unk_c3e); + rfu_UNI_clearRecvNewDataFlag(Rfu.unk_c3e); + } + LinkRfu_REQ_SendData_HandleParentRelationship(TRUE); +} + +static void sub_80F8DA8(u16 unused) +{ + Rfu.unk_cdb = 1; +} + +void sub_80F8DC0(void) +{ + u8 i; + + if (gQuestLogState == 2 || gQuestLogState == 3) + return; + + sub_80FD52C(); + if (Rfu.unk_0c == 1) + { + if (FuncIsActiveTask(sub_80F8738) == TRUE) + { + DestroyTask(Rfu.unk_67); + sub_80F85F8(); + } + } + else if (Rfu.unk_0c == 0) + { + if (FuncIsActiveTask(sub_80F893C) == TRUE) + { + DestroyTask(Rfu.unk_67); + sub_80F85F8(); + } + } + else if (Rfu.unk_0c == 2) + { + if (FuncIsActiveTask(sub_80F8B34) == TRUE) + { + DestroyTask(Rfu.unk_67); + sub_80F85F8(); + } + } + for (i = 0; i < NELEMS(gUnknown_843ED88); i++) + { + if (FuncIsActiveTask(gUnknown_843ED88[i]) == TRUE) + { + DestroyTask(FindTaskIdByFunc(gUnknown_843ED88[i])); + } + } +} + +static void sub_80F8E74(void) +{ + if (gQuestLogState == 2 || gQuestLogState == 3) + return; + Rfu.unk_67 = CreateTask(sub_80F8738, 1); +} + +static bool8 sub_80F8EA4(void) +{ + if (Rfu.unk_04 == 7 && Rfu.unk_ccd) + { + return TRUE; + } + return FALSE; +} + +static bool32 sub_80F8ECC(void) +{ + if (Rfu.unk_04 == 7 && !sub_80FD610(gRfuLinkStatus->partner[Rfu.unk_c3d].id, 240)) + { + Rfu.unk_04 = 9; + return TRUE; + } + return FALSE; +} + +static void sub_80F8F10(void) +{ + if (gQuestLogState == 2 || gQuestLogState == 3) + return; + Rfu.unk_67 = CreateTask(sub_80F893C, 1); +} + +bool8 sub_80F8F40(void) +{ + if (gUnknown_3005E10.unk_00) + { + return TRUE; + } + return FALSE; +} + +void sub_80F8F5C(void) +{ + Rfu.unk_04 = 4; + Rfu.unk_ce7 = gUnknown_3005E10.unk_00; +} + +bool32 sub_80F8F7C(bool32 a0) +{ + if (Rfu.unk_04 == 17 || a0) + { + Rfu.unk_04 = 18; + return TRUE; + } + return FALSE; +} + +void sub_80F8FA0(void) +{ + Rfu.unk_04 = 14; +} + +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 sub_80F8FD4(void) +{ + s32 i, j; + + for (i = 0; i < 5; i++) + { + struct UnkRfuStruct_2 *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]; + } + } + CpuFill16(0, gRecvCmds, sizeof gRecvCmds); +} + +static void sub_80F9038(void) +{ + s32 i; + for (i = 0; i < 7; i++) + { + gRecvCmds[0][i] = gSendCmd[i]; + } + for (i = 0; i < 7; i++) + { + gSendCmd[i] = 0; + } +} + +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) + { + Rfu.unk_c3c = 0; + } + if (r2) + { + return; + } + } + if (Rfu.unk_c3c == 0) + { + sub_80FC79C(&Rfu.unk_9e8, Rfu.unk_4c); + sub_80FC828(&Rfu.unk_c1c, Rfu.unk_4c); + } +} + +bool32 IsRfuRecvQueueEmpty(void) +{ + s32 i; + s32 j; + + if (gRfuLinkStatus->sendSlotUNIFlag == 0) + { + return FALSE; + } + for (i = 0; i < 5; i++) + { + for (j = 0; j < 7; j++) + { + if (gRecvCmds[i][j] != 0) + { + return FALSE; + } + } + } + return TRUE; +} + +static bool32 sub_80F911C(void) +{ + if (Rfu.unk_04 < 20) + { + rfu_REQ_recvData(); + rfu_waitREQComplete(); + LinkRfu_REQ_SendData_HandleParentRelationship(FALSE); + } + else + { + Rfu.unk_cdb = 0; + if ((Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag) == Rfu.unk_ce2 && (Rfu.unk_ce2 & gRfuLinkStatus->connSlotFlag)) + { + if (!Rfu.unk_cdc) + { + if (Rfu.unk_ce3) + { + sub_80FBCF8(Rfu.unk_ce3); + Rfu.unk_ce3 = 0; + if (Rfu.unk_ce4 == 1) + { + sub_80FB9E4(2, 0x8000); + sub_80FB0E8(0x8000); + return FALSE; + } + if (!gUnknown_3005E10.unk_00) + { + sub_80F8DC0(); + gReceivedRemoteLinkPlayers = 0; + return FALSE; + } + } + sub_80F8FD4(); + rfu_UNI_readySendData(Rfu.unk_cda); + LinkRfu_REQ_SendData_HandleParentRelationship(TRUE); + } + else + { + rfu_REQ_PARENT_resumeRetransmitAndChange(); + } + Rfu.unk_0e = 1; + } + } + return FALSE; +} + +static bool32 sub_80F9204(void) +{ + u16 i; + u16 flags; + u8 r0; + u16 j; + u8 retval; + + if (Rfu.unk_04 >= 20 && Rfu.unk_0e == 1) + { + rfu_waitREQComplete(); + while (Rfu.unk_cdb == 0) + { + if (Rfu.unk_ee != 0) + { + return FALSE; + } + } + rfu_REQ_recvData(); + rfu_waitREQComplete(); + if ((gUnknown_3005E10.unk_03 & Rfu.unk_ce2) == Rfu.unk_ce2) + { + Rfu.unk_cdc = 0; + gUnknown_203AC08.unk_06++; + flags = gUnknown_3005E10.unk_00; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (flags & 1) + { + if (Rfu.unk_14[i][1]) + { + 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); + } + 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]; + for (j = 0; j < 7; j++) + { + gRecvCmds[r0][j] = (Rfu.unk_14[i][(j << 1) + 1] << 8) | Rfu.unk_14[i][(j << 1) + 0]; + Rfu.unk_14[i][(j << 1) + 1] = 0; + Rfu.unk_14[i][(j << 1) + 0] = 0; + } + } + } + rfu_UNI_clearRecvNewDataFlag(i); + } + flags >>= 1; + } + sub_80F9038(); + sub_80F9868(0); + CallRfuFunc(); + if (Rfu.unk_ce5 && !Rfu.unk_cd9) + { + gUnknown_203AC08.unk_0e = 0; + rfu_clearSlot(3, Rfu.unk_cda); + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((Rfu.unk_ce5 >> i) & 1) + { + rfu_setRecvBuffer(0x10, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i])); + } + } + sub_80F887C(Rfu.unk_ce2, Rfu.unk_ce2 | Rfu.unk_ce5); + Rfu.unk_ce9 = Rfu.unk_ce5; + Rfu.unk_ce2 |= 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); + } + } + else + { + Rfu.unk_cdc = 1; + Rfu.unk_0e = 0; + } + Rfu.unk_0e = 0; + } + retval = Rfu.unk_cdc; + return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE; +} + +static void sub_80F94BC(u16 *a0, u8 *a1) +{ + s32 i; + + if (a0[0]) + { + a0[0] |= (Rfu.unk_102 << 5); + Rfu.unk_102 = (Rfu.unk_102 + 1) & 7; + for (i = 0; i < 7; i++) + { + a1[2 * i + 1] = a0[i] >> 8; + a1[2 * i + 0] = a0[i]; + } + } + else + { + for (i = 0; i < 14; i++) + a1[i] = 0; + } +} + +static bool32 sub_80F9514(void) +{ + u8 i; + u8 j; + u8 sp00[MAX_RFU_PLAYERS * (2 * (CMD_LENGTH - 1))]; + u8 sp48[2 * (CMD_LENGTH - 1)]; + u8 switchval; + + sub_80FC6E8(&Rfu.unk_124, sp00); + for (i = 0; i < MAX_RFU_PLAYERS; i++) + { + for (j = 0; j < CMD_LENGTH - 1; j++) + { + 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) + { + rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); + rfu_waitREQComplete(); + switchval = sub_80FB9F4(); + if (switchval != 1 && switchval != 6 && switchval != 9) + sub_80FB9E4(2, 0x9000); + rfu_clearAllSlot(); + gReceivedRemoteLinkPlayers = FALSE; + Rfu.RfuFunc = NULL; + if (Rfu.unk_ce4 == 1) + { + sub_80FB9E4(2, 0x9000); + sub_80FB0E8(0x9000); + } + gUnknown_3005E10.unk_04 = gUnknown_3005E10.unk_05 = 0; + Rfu.unk_ce4 = 0; + } + if (Rfu.unk_cd0) + { + Rfu.unk_cd0--; + CallRfuFunc(); + sub_80F94BC(gSendCmd, sp48); + sub_80FC63C(&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) +{ + s32 i, j; + + const u8 *r10 = Rfu.unk_6c.unk_04; + for (i = 0; i < Rfu.unk_6c.unk_02; i++) + { + if (!(flags & 1)) + { + gUnknown_3002008[0] = (~0x76ff) | i; + for (j = 0; j < 7; j++) + { + gUnknown_3002008[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]; + + j++;j--; // Needed to match; + } + sub_80FC63C(&Rfu.unk_9e8, gUnknown_3001FF8); + Rfu.unk_6c.unk_0c |= (1 << i); + } + flags >>= 1; + } +} + +void Rfu_SetBlockReceivedFlag(u8 a0) +{ + if (Rfu.unk_0c == 1 && a0) + Rfu.unk_61[a0] = 1; + else + Rfu.unk_5c[a0] = 1; +} + +void Rfu_ResetBlockReceivedFlag(u8 a0) +{ + Rfu.unk_5c[a0] = 0; + Rfu.unk_80[a0].unk_12 = 0; +} + +static u8 sub_80F9770(const u8 *a0) +{ + u8 i; + + if (Rfu.unk_0c == 1) + return FALSE; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + Rfu.unk_cde[i] = a0[i]; + } + return a0[Rfu.unk_c3e]; +} + +static void rfu_func_080F97B8(void) +{ + static u8 gUnknown_3001188; + if (gReceivedRemoteLinkPlayers + && gHeldKeyCodeToSend != LINK_KEY_CODE_NULL + && gLinkTransferringData != TRUE) + { + gUnknown_3001188++; + gHeldKeyCodeToSend |= (gUnknown_3001188 << 8); + sub_80F9D04(0xbe00); + } +} + +struct GFtgtGname *sub_80F9800(void) +{ + return &gUnknown_3005440; +} + +bool32 IsSendingKeysToRfu(void) +{ + return Rfu.RfuFunc == rfu_func_080F97B8; +} + +void sub_80F9828(void) +{ + AGB_ASSERT_EX(Rfu.RfuFunc == NULL, ABSPATH("rfu.c"), 1473); + Rfu.RfuFunc = rfu_func_080F97B8; +} + +void Rfu_set_zero(void) +{ + Rfu.RfuFunc = NULL; +} + +static void sub_80F9868(u8 unused) +{ + u16 i; + u16 j; + + for (i = 0; i < MAX_RFU_PLAYERS; i++) + { + switch (gRecvCmds[i][0] & 0xff00) + { + case 0x7800: + if (Rfu.unk_0c == 0 && gReceivedRemoteLinkPlayers != 0) + return; + // fallthrough + case 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) + { + 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.unk_5c[i] = 0; + } + break; + case 0x8900: + if (Rfu.unk_80[i].unk_12 == 1) + { + Rfu.unk_80[i].unk_00 = gRecvCmds[i][0] & 0xff; + Rfu.unk_80[i].unk_08 |= (1 << Rfu.unk_80[i].unk_00); + 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]) + { + Rfu.unk_80[i].unk_12 = 2; + Rfu_SetBlockReceivedFlag(i); + if (sub_80F9800()->unk_0a_0 == 0x45 && gReceivedRemoteLinkPlayers != 0 && Rfu.unk_0c == 0) + sub_80FAA58(gBlockRecvBuffer); + } + } + break; + case 0xa100: + Rfu_InitBlockSend(gUnknown_843EC64[gRecvCmds[i][1]].buffer, (u16)gUnknown_843EC64[gRecvCmds[i][1]].size); + break; + case 0x5f00: + Rfu.unk_e4[i] = 1; + break; + case 0x6600: + if (Rfu.unk_100 == gRecvCmds[i][1]) + Rfu.unk_e9[i] = 1; + break; + case 0xed00: + if (Rfu.unk_0c == 0) + { + if (gReceivedRemoteLinkPlayers != 0) + { + if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag) + { + gReceivedRemoteLinkPlayers = 0; + sub_80FEB14(); + Rfu.unk_ce4 = gRecvCmds[i][2]; + } + Rfu.playerCount = gRecvCmds[i][3]; + sub_80FA9D0(gRecvCmds[i][1]); + } + } + else + { + sub_80F9D04(0xee00); + gSendCmd[1] = gRecvCmds[i][1]; + gSendCmd[2] = gRecvCmds[i][2]; + gSendCmd[3] = gRecvCmds[i][3]; + } + break; + case 0xee00: + if (Rfu.unk_0c == 1) + { + Rfu.unk_ce3 |= gRecvCmds[i][1]; + Rfu.unk_ce4 = gRecvCmds[i][2]; + sub_80FA9D0(gRecvCmds[i][1]); + } + break; + case 0xbe00: + gLinkPartnersHeldKeys[i] = gRecvCmds[i][1]; + break; + } + if (Rfu.unk_0c == 1 && Rfu.unk_61[i]) + { + if (Rfu.unk_61[i] == 4) + { + Rfu.unk_5c[i] = 1; + Rfu.unk_61[i] = 0; + } + else + Rfu.unk_61[i]++; + } + } +} + +static bool8 sub_80F9C50(void) +{ + s32 i; + + for (i = 0; i < 5; i++) + { + if (Rfu.unk_80[i].unk_12) + return FALSE; + } + return TRUE; +} + +static bool8 sub_80F9C78(void) +{ + s32 i; + + for (i = 0; i < Rfu.playerCount; i++) + { + if (Rfu.unk_80[i].unk_12 != 2 || Rfu.unk_5c[i] != 1) + return FALSE; + } + return TRUE; +} + +static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *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; +} + +u8 Rfu_GetBlockReceivedStatus(void) +{ + u8 flags = 0; + s32 i; + + for (i = 0; i < 5; i++) + { + if (Rfu.unk_80[i].unk_12 == 2 && Rfu.unk_5c[i] == 1) + { + flags |= (1 << i); + } + } + return flags; +} + +static void sub_80F9D04(u16 command) +{ + u8 i; + u8 *buff; + u8 tmp; + + gSendCmd[0] = command; + switch (command) + { + case 0x8800: + gSendCmd[1] = Rfu.unk_6c.unk_02; + gSendCmd[2] = Rfu.unk_6c.unk_11 + 0x80; + break; + case 0xa100: + if (sub_80F9C50()) + gSendCmd[1] = Rfu.unk_5a; + break; + case 0x7700: + case 0x7800: + tmp = Rfu.unk_ce2 ^ Rfu.unk_ce3; + 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]; + break; + case 0x6600: + case 0x5f00: + gSendCmd[1] = Rfu.unk_100; + break; + case 0x2f00: + for (i = 0; i < 6; i++) + gSendCmd[1 + i] = Rfu.unk_f2[i]; + break; + case 0xbe00: + gSendCmd[1] = gHeldKeyCodeToSend; + break; + case 0xee00: + break; + case 0xed00: + break; + } +} + +void sub_80F9E2C(void *a0) +{ + if (gSendCmd[0] == 0 && !sub_80FBA00()) + { + memcpy(Rfu.unk_f2, a0, sizeof(Rfu.unk_f2)); + sub_80F9D04(0x2f00); + } +} + +bool32 Rfu_InitBlockSend(const u8 *src, size_t size) +{ + bool8 r4; + AGB_ASSERT_EX(size<=252, ABSPATH("rfu.c"), 1793); + if (Rfu.RfuFunc != NULL) + return FALSE; + if (gSendCmd[0] != 0) + return FALSE; + if (Rfu.unk_6c.unk_10 != 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; + else + { + if (src != gBlockSendBuffer) + memcpy(gBlockSendBuffer, src, size); + Rfu.unk_6c.unk_04 = gBlockSendBuffer; + } + sub_80F9D04(0x8800); + Rfu.RfuFunc = rfufunc_80F9F44; + Rfu.unk_5b = 0; + return TRUE; +} + +static void rfufunc_80F9F44(void) +{ + if (gSendCmd[0] == 0) + { + sub_80F9D04(0x8800); + if (Rfu.unk_0c == 1) + { + if (++Rfu.unk_5b > 2) + Rfu.RfuFunc = sub_80F9FA8; + } + else + { + if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == 0x8800) + Rfu.RfuFunc = sub_80F9FA8; + } + } +} +static void sub_80F9FA8(void) +{ + s32 i; + const u8 *src = Rfu.unk_6c.unk_04; + gSendCmd[0] = 0x8900 | Rfu.unk_6c.unk_00; + 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) + { + Rfu.unk_6c.unk_10 = 0; + Rfu.RfuFunc = rfufunc_80FA020; + } +} + +static void rfufunc_80FA020(void) +{ + const u8 *src = Rfu.unk_6c.unk_04; + u8 mpId = GetMultiplayerId(); + s32 i; + if (Rfu.unk_0c == 0) + { + gSendCmd[0] = (~0x76ff) | (Rfu.unk_6c.unk_02 - 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) + { + if (Rfu.unk_80[mpId].unk_08 != gUnknown_843EBD4[Rfu.unk_80[mpId].unk_02]) + { + sub_80F965C(mpId, Rfu.unk_80[mpId].unk_08); + gUnknown_203AC08.unk_64++; + } + else + Rfu.RfuFunc = NULL; + } + } + else + Rfu.RfuFunc = NULL; +} + +bool8 sub_80FA0F8(u8 a0) +{ + Rfu.unk_5a = a0; + sub_80F9D04(0xa100); + return TRUE; +} + +static void sub_80FA114(void) +{ + rfu_clearAllSlot(); + sub_80FD52C(); + gReceivedRemoteLinkPlayers = 0; + Rfu.unk_ef = 1; + Rfu.RfuFunc = NULL; +} + +static void sub_80FA140(void) +{ + rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); + rfu_waitREQComplete(); + sub_80FA114(); +} + +static void sub_80FA160(void) +{ + if (Rfu.unk_0c == 0) + { + sub_80FEB14(); + Rfu.unk_ce4 = 2; + } + else + Rfu.RfuFunc = sub_80FA140; +} + +void LinkRfu_FatalError(void) +{ + sub_80FEB14(); + Rfu.unk_ce4 = 1; + Rfu.unk_ce3 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; +} + +static void sub_80FA1C4(void) +{ + s32 i; + u8 playerCount = Rfu.playerCount; + s32 count = 0; + + for (i = 0; i < MAX_RFU_PLAYERS; i++) + { + if (Rfu.unk_e4[i]) + count++; + } + if (count == playerCount) + { + gBattleTypeFlags &= (u16)~BATTLE_TYPE_20; + if (Rfu.unk_0c == 0) + { + Rfu.unk_ee = 3; + sub_80FA160(); + } + else + Rfu.RfuFunc = sub_80FA160; + } +} + +static void sub_80FA224(void) +{ + if (gSendCmd[0] == 0 && Rfu.unk_ce8 == 0) + { + sub_80F9D04(0x5f00); + Rfu.RfuFunc = sub_80FA1C4; + } +} + +static void sub_80FA25C(u8 taskId) +{ + if (Rfu.RfuFunc == NULL) + { + Rfu.unk_cd9 = 1; + Rfu.RfuFunc = sub_80FA224; + DestroyTask(taskId); + } +} + +void task_add_05_task_del_08FA224_when_no_RfuFunc(void) +{ + if (!FuncIsActiveTask(sub_80FA25C)) + CreateTask(sub_80FA25C, 5); +} + +static void sub_80FA2B0(void) +{ + u8 playerCount; + u8 i; + + if (GetMultiplayerId() != 0) + { + if (Rfu.unk_124.unk_8c2 == 0 && Rfu.unk_fe > 0x3c) + { + sub_80F9D04(0x6600); + Rfu.unk_fe = 0; + } + } + playerCount = GetLinkPlayerCount(); + for (i = 0; i < playerCount; i++) + { + if (Rfu.unk_e9[i] == 0) + break; + } + if (i == playerCount) + { + for (i = 0; i < MAX_RFU_PLAYERS; i++) + Rfu.unk_e9[i] = 0; + Rfu.unk_100++; + Rfu.RfuFunc = NULL; + } + Rfu.unk_fe++; +} + +static void sub_80FA350(void) +{ + if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + { + sub_80F9D04(0x6600); + Rfu.RfuFunc = sub_80FA2B0; + } +} + +static void sub_80FA388(void) +{ + u8 i; + u8 playerCount; + + if (GetMultiplayerId() != 0) + { + if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + { + sub_80F9D04(0x6600); + Rfu.RfuFunc = sub_80FA2B0; + } + } + else + { + playerCount = GetLinkPlayerCount(); + for (i = 1; i < playerCount; i++) + { + if (Rfu.unk_e9[i] == 0) + break; + } + if (i == playerCount) + { + if (Rfu.unk_124.unk_8c2 == 0 && gSendCmd[0] == 0) + { + sub_80F9D04(0x6600); + Rfu.RfuFunc = sub_80FA350; + } + } + } +} + +void sub_80FA42C(void) +{ + if (Rfu.RfuFunc == NULL) + { + Rfu.RfuFunc = sub_80FA388; + Rfu.unk_fe = 0; + } +} + +bool32 sub_80FA44C(u32 a0) +{ + s32 i; + for (i = 0; gUnknown_843EC8C[i] != a0; i++) + { + if (gUnknown_843EC8C[i] == 0xFFFF) + return FALSE; + } + return TRUE; +} + +u8 sub_80FA484(bool32 a0) +{ + if (!a0) + return sub_80FEA34(0, 0); + sub_80FEA34(1, 0x258); + return 0; +} + +void sub_80FA4A8(void) +{ + Rfu.unk_cd9 = 1; + sub_80FD760(FALSE); +} + +u8 LinkRfu_GetMultiplayerId(void) +{ + if (Rfu.unk_0c == 1) + return 0; + return Rfu.unk_cce; +} + +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 sub_80FA528(void) +{ + s32 i; + bool8 retval = FALSE; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (Rfu.unk_cd1[i] < 5 || Rfu.unk_cd1[i] > 6) + { + if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) + { + if (Rfu.unk_cd5[i] == 8) + { + Rfu.unk_cd1[i] = 9; + Rfu.unk_cd5[i] = 10; + rfu_clearSlot(8, i); + rfu_NI_setSendData(1 << i, 8, Rfu.unk_cd1 + i, 1); + retval = TRUE; + } + + } + else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED) + { + rfu_clearSlot(8, i); + } + } + } + return retval; +} + +bool32 sub_80FA5D4(void) +{ + u8 flags = 0; + s32 i; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (Rfu.unk_cd5[i] == 11) + { + flags |= (1 << i); + Rfu.unk_cd5[i] = 0; + } + } + if (flags) + { + rfu_REQ_disconnect(flags); + rfu_waitREQComplete(); + } + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (Rfu.unk_cd5[i] == 10 || Rfu.unk_cd5[i] == 11) + return TRUE; + } + return FALSE; +} + +bool32 sub_80FA634(u16 a0, const u8 *a1) +{ + u8 r1 = sub_80FBC70(a1, a0); + if (r1 == 0xFF) + return TRUE; + if (Rfu.unk_cd1[r1] == 9) + return TRUE; + return FALSE; +} + +void sub_80FA670(u8 a0, u16 a1, const u8 *a2) +{ + u8 r4 = sub_80FBC70(a2, a1); + Rfu.unk_cd1[r4] = a0; + rfu_clearSlot(4, r4); + rfu_NI_setSendData(1 << r4, 8, Rfu.unk_cd1 + r4, 1); +} + +void sub_80FA6BC(void) +{ + Rfu.unk_c85 = 8; + rfu_clearSlot(4, Rfu.unk_c3e); + rfu_NI_setSendData(1 << Rfu.unk_c3e, 8, &Rfu.unk_c85, 1); +} + +u32 sub_80FA6FC(u16 a0, const u8 *a1) +{ + u8 r0 = sub_80FBC70(a1, a0); + if (r0 == 0xFF) + return 2; + if (gRfuSlotStatusNI[r0]->send.state == 0) + return 1; + return 0; +} + +static void sub_80FA738(void) +{ + s32 i; + + sub_80FA528(); + 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.unk_cd5[i] == 10) + Rfu.unk_cd5[i] = 11; + rfu_clearSlot(4, i); + } + } +} + +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(4, Rfu.unk_c3e); + } + if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) + { + rfu_clearSlot(8, Rfu.unk_c3e); + sub_80FB9E4(Rfu.unk_c86, 0); + retval = Rfu.unk_c86; + } + else if (gRfuSlotStatusNI[Rfu.unk_c3e]->recv.state == SLOT_STATE_RECV_FAILED) + { + rfu_clearSlot(8, Rfu.unk_c3e); + retval = 6; + } + return retval; +} + +static void sub_80FA834(u8 taskId) +{ + s32 i; + + if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2) + { + Rfu.unk_ce8 = 0; + DestroyTask(taskId); + } + switch (gTasks[taskId].data[0]) + { + case 0: + if (sub_80F9C50()) + { + ResetBlockReceivedFlags(); + sub_800B0B4(); + gTasks[taskId].data[0]++; + } + break; + case 1: + if (Rfu.unk_0c == 1) + { + if (gReceivedRemoteLinkPlayers) + sub_80F9D04(0x7800); + else + sub_80F9D04(0x7700); + gTasks[taskId].data[0] = 101; + } + else + gTasks[taskId].data[0] = 2; + break; + case 101: + if (gSendCmd[0] == 0) + gTasks[taskId].data[0] = 2; + break; + case 2: + if (Rfu.playerCount) + gTasks[taskId].data[0]++; + break; + case 3: + if (Rfu.unk_0c == 1) + { + if (sub_80F9C50()) + { + Rfu.unk_5a = 0; + sub_80F9D04(0xa100); + gTasks[taskId].data[0]++; + } + } + else + gTasks[taskId].data[0]++; + break; + case 4: + if (sub_80F9C78()) + gTasks[taskId].data[0]++; + break; + case 5: + for (i = 0; i < Rfu.playerCount; i++) + { + sub_800B110(i); + Rfu_ResetBlockReceivedFlag(i); + } + gTasks[taskId].data[0]++; + break; + case 6: + DestroyTask(taskId); + gReceivedRemoteLinkPlayers = 1; + Rfu.unk_ce8 = 0; + sub_80FEA34(1, 0x258); + if (Rfu.unk_ce6) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((Rfu.unk_ce6 >> i) & 1) + { + Rfu.unk_ce5 = 1 << i; + Rfu.unk_ce6 ^= (1 << i); + } + } + } + break; + } +} + +static void sub_80FA9D0(u16 a0) +{ + s32 i; + + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((a0 >> i) & 1) + Rfu.unk_cde[i] = 0; + } +} + +static void sub_80FA9FC(const struct UnkRfuStruct_8010A14 *a0) +{ + s32 i; + Rfu.playerCount = a0->unk_0f; + for (i = 0; i < RFU_CHILD_MAX; i++) + Rfu.unk_cde[i] = a0->unk_10[i]; + for (i = 0; i < MAX_RFU_PLAYERS; i++) + { + gLinkPlayers[i] = a0->unk_14[i]; + sub_800B284(gLinkPlayers + i); + } +} + +static void sub_80FAA58(void *a0) +{ + if (strcmp("PokemonSioInfo", ((struct UnkRfuStruct_8010A14 *)a0)->unk_00) == 0) + { + sub_80FA9FC(a0); + CpuFill16(0, a0, sizeof(struct UnkRfuStruct_8010A14)); + ResetBlockReceivedFlag(0); + } +} + +static void sub_80FAA94(u8 taskId) +{ + s32 i; + struct LinkPlayerBlock *r2; + struct UnkRfuStruct_8010A14 *r5; + u8 r4 = Rfu.unk_cde[gUnknown_843EC38[Rfu.unk_ce9]]; + if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2) + { + Rfu.unk_ce8 = 0; + DestroyTask(taskId); + } + switch (gTasks[taskId].data[0]) + { + case 0: + if (gSendCmd[0] == 0) + { + ResetBlockReceivedFlag(r4); + sub_80F9D04(0x7800); + gTasks[taskId].data[0]++; + } + break; + case 1: + if (gSendCmd[0] == 0) + gTasks[taskId].data[0]++; + break; + case 2: + if ((GetBlockReceivedStatus() >> r4) & 1) + { + ResetBlockReceivedFlag(r4); + r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4]; + gLinkPlayers[r4] = r2->linkPlayer; + sub_800B284(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; + for (i = 0; i < RFU_CHILD_MAX; i++) + r5->unk_10[i] = Rfu.unk_cde[i]; + memcpy(r5->unk_14, gLinkPlayers, sizeof gLinkPlayers); + gTasks[taskId].data[0]++; + // fallthrough + case 4: + r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer; + r5->unk_0f = 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); + if (SendBlock(0, gBlockSendBuffer, 0xa0)) + gTasks[taskId].data[0]++; + break; + case 5: + if (IsLinkTaskFinished() && GetBlockReceivedStatus() & 1) + { + CpuFill16(0, gBlockRecvBuffer, sizeof(struct UnkRfuStruct_8010A14)); + ResetBlockReceivedFlag(0); + Rfu.unk_ce8 = 0; + if (Rfu.unk_ce6) + { + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((Rfu.unk_ce6 >> i) & 1) + { + Rfu.unk_ce5 = 1 << i; + Rfu.unk_ce6 ^= (1 << i); + Rfu.unk_ce8 = 1; + break; + } + } + } + DestroyTask(taskId); + } + break; + } +} + +static void sub_80FACF0(u8 taskId) +{ + if (Rfu.unk_f1 == 1 || Rfu.unk_f1 == 2) + DestroyTask(taskId); + switch (gTasks[taskId].data[0]) + { + case 0: + if (Rfu.playerCount) + { + sub_800B0B4(); + 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) + { + sub_80FA9FC((const struct UnkRfuStruct_8010A14 *)gBlockRecvBuffer); + ResetBlockReceivedFlag(0); + gReceivedRemoteLinkPlayers = 1; + DestroyTask(taskId); + } + break; + } +} + +static void sub_80FAD98(void) +{ + if (Rfu.unk_ee == 1 && gUnknown_3005E10.unk_02 == 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; + CloseLink(); + } + else if (Rfu.unk_9e8.unk_233 == 1 || Rfu.unk_124.unk_8c3 == 1) + { + if (gUnknown_3005E10.unk_02) + sub_80FEB14(); + sub_80FB9E4(1, 0x7000); + sub_80FB0E8(0x7000); + } +} + +static void rfu_REQ_recvData_then_sendData(void) +{ + if (gUnknown_3005E10.unk_06 == 1) + { + rfu_REQ_recvData(); + rfu_waitREQComplete(); + LinkRfu_REQ_SendData_HandleParentRelationship(0); + } +} + +bool32 sub_80FAE94(void) +{ + bool32 retval = FALSE; + Rfu.unk_ccd = 0; + sub_80FDA30(Random()); + if (Rfu.unk_ef == 0) + { + switch (Rfu.unk_0c) + { + case 1: + sub_80F911C(); + break; + case 0: + retval = sub_80F9514(); + break; + case 2: + rfu_REQ_recvData_then_sendData(); + break; + } + } + return retval; +} + +bool32 sub_80FAEF0(void) +{ + bool32 retval = FALSE; + if (Rfu.unk_ef == 0) + { + if (Rfu.unk_0c == 1) + retval = sub_80F9204(); + sub_80FAD98(); + } + return retval; +} + +static void sub_80FAF1C(void) +{ + StringCopy(gUnknown_3005E00, gSaveBlock2Ptr->playerName); +} + +void sub_80FAF34(void) +{ + memset(&gUnknown_3005440, 0, RFU_GAME_NAME_LENGTH); + sub_80FCB54(&gUnknown_3005440, 0, 0, 0); +} + +void sub_80FAF58(u8 a0, u32 a1, u32 a2) +{ + sub_80FCB54(&gUnknown_3005440, a0, a2, a1); +} + +void sub_80FAF74(bool32 a0, bool32 a1) +{ + gUnknown_3005440.unk_00.unk_00_4 = a0; + gUnknown_3005440.unk_00.unk_00_5 = a1; +} + +void sub_80FAFA0(u32 type, u32 species, u32 level) +{ + gUnknown_3005440.type = type; + gUnknown_3005440.species = species; + gUnknown_3005440.level = level; +} + +void sub_80FAFE0(u8 a0) +{ + gUnknown_3005440.unk_0a_7 = a0; + rfu_REQ_configGameData(0, 2, (void *)&gUnknown_3005440, gUnknown_3005E00); +} + +void sub_80FB008(u8 a0, u32 a1, u32 a2) +{ + if (a0) + sub_80FAF58(a0, a1, a2); + rfu_REQ_configGameData(0, 2, (void *)&gUnknown_3005440, gUnknown_3005E00); +} + +void sub_80FB030(u32 a0) +{ + s32 i; + u32 r5; + u32 r7; + s32 r8; + + if (sub_80F9800()->unk_0a_0 == 0x45) + { + r5 = 0; + r7 = 0; + r8 = Rfu.unk_ce2 ^ Rfu.unk_ce3; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((r8 >> i) & 1) + { + r7 |= ((0x80 | ((gLinkPlayers[Rfu.unk_cde[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.unk_cde[i]].trainerId & 7)) << (r5 << 3)); + r5++; + if (r5 == a0 - 1) + break; + } + } + sub_80FB008(0x45, r7, 0); + } +} + +static void sub_80FB0E8(u32 a0) +{ + if (Rfu.unk_ee == 0) + { + Rfu.unk_10 = gUnknown_3005E10.unk_14; + Rfu.unk_12 = gUnknown_3005E10.unk_16; + Rfu.unk_0a = a0; + Rfu.unk_ee = 1; + } +} + +static void sub_80FB118(void) +{ + Rfu.unk_ee = 0; +} + +void sub_80FB128(bool32 a0) +{ + if (!a0) + Rfu.unk_ee = 0; + else + Rfu.unk_ee = 4; +} + +static void sub_80FB154(void) +{ + sub_80FBE20(gUnknown_3005E10.unk_00, 1); + Rfu.RfuFunc = NULL; +} + +static void sub_80FB174(void) +{ + Rfu.RfuFunc = sub_80FB154; +} + +static void sub_80FB184(u8 a0, u8 unused1) +{ + u8 i; + u8 r6 = 0; + switch (a0) + { + case 0x00: + Rfu.unk_04 = 2; + break; + case 0x10: + break; + case 0x11: + sub_80FB564(gUnknown_3005E10.unk_14); + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((gUnknown_3005E10.unk_14 >> i) & 1) + { + struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; + if (structPtr->unk_0a_0 == sub_80F9800()->unk_0a_0) + { + Rfu.unk_cd1[i] = 0; + Rfu.unk_cd5[i] = 0; + rfu_setRecvBuffer(0x20, i, Rfu.unk_cd5 + i, 1); + } + else + { + r6 |= (1 << i); + } + } + } + if (r6) + { + rfu_REQ_disconnect(r6); + rfu_waitREQComplete(); + } + break; + case 0x12: + break; + case 0x13: + break; + case 0x14: + if (Rfu.unk_ce7 != gUnknown_3005E10.unk_00) + { + rfu_REQ_disconnect(Rfu.unk_ce7 ^ gUnknown_3005E10.unk_00); + rfu_waitREQComplete(); + } + Rfu.unk_04 = 0x11; + break; + case 0x31: + Rfu.unk_f0 = 1; + break; + case 0x32: + Rfu.unk_f0 = 3; + break; + case 0x30: + case 0x33: + Rfu.unk_f0 = 4; + Rfu.unk_ce2 &= ~gUnknown_3005E10.unk_14; + if (gReceivedRemoteLinkPlayers == 1) + { + if (Rfu.unk_ce2 == 0) + sub_80FB0E8(a0); + else + sub_80FB174(); + } + sub_80FB9E4(2, a0); + break; + case 0x34: + break; + case 0x42 ... 0x44: + break; + case 0xf3: + sub_80FB9E4(1, a0); + sub_80FB0E8(a0); + Rfu.unk_ef = 1; + break; + case 0xf0 ... 0xf2: + case 0xff: + sub_80FB0E8(a0); + sub_80FB9E4(1, a0); + Rfu.unk_cdb = 1; + break; + } +} + +static const u8 unref_843EDF3[] = _(" あきと"); + +static void sub_80FB37C(u8 a0, u8 unused1) +{ + switch (a0) + { + case 0x00: + Rfu.unk_04 = 6; + break; + case 0x20: + Rfu.unk_ccd = gUnknown_3005E10.unk_14; + break; + case 0x21: + break; + case 0x22: + Rfu.unk_c3e = gUnknown_3005E10.unk_14; + break; + case 0x23: + sub_80FB9E4(2, a0); + break; + case 0x24: + Rfu.unk_04 = 11; + Rfu.unk_c85 = 0; + Rfu.unk_c86 = 0; + rfu_setRecvBuffer(0x20, Rfu.unk_c3e, &Rfu.unk_c86, 1); + rfu_setRecvBuffer(0x10, Rfu.unk_c3e, Rfu.unk_c3f, 70); + break; + case 0x25: + sub_80FB9E4(2, 0x25); + break; + case 0x30: + Rfu.unk_f0 = 2; + if (Rfu.unk_c86 == 6) + break; + case 0x33: + if (Rfu.unk_f0 != 2) + Rfu.unk_f0 = 4; + if (Rfu.unk_c86 != 9) + sub_80FB9E4(2, a0); + nullsub_87("LINK LOSS DISCONNECT!", 5, 5); + if (gReceivedRemoteLinkPlayers == 1) + sub_80FB0E8(a0); + break; + case 0x31: + Rfu.unk_f0 = 1; + nullsub_87("LINK LOSS RECOVERY NOW", 5, 5); + break; + case 0x32: + Rfu.unk_f0 = 3; + Rfu.unk_c3c = 1; + break; + case 0x34: + break; + case 0x42 ... 0x44: + break; + case 0xF3: + sub_80FB9E4(1, a0); + sub_80FB0E8(a0); + Rfu.unk_ef = 1; + break; + case 0xF0 ... 0xF2: + case 0xFF: + sub_80FB9E4(1, a0); + sub_80FB0E8(a0); + Rfu.unk_cdb = 1; + break; + } +} + +static void sub_80FB564(s32 a0) +{ + s32 i; + + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((a0 >> i) & 1) + { + Rfu.unk_cea[i] = 0; + Rfu.unk_cee[i] = 0xFF; + } + } +} + +static u8 sub_80FB5A0(s32 a0) +{ + u8 ret = 0; + u8 i; + + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((a0 >> i) & 1) + { + struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; + if (structPtr->unk_0a_0 == 0x45) + ret |= (1 << i); + } + } + + return ret; +} + +static void sub_80FB5EC(u8 a0, u8 unused1) +{ + u8 r1; + + switch (a0) + { + case 0x00: + Rfu.unk_04 = 0x11; + break; + case 0x10: + sub_80FB9E4(4, 0); + break; + case 0x11: + if (sub_80F9800()->unk_0a_0 == 0x45 && Rfu.unk_cd9 == 0) + { + u8 idx = sub_80FB5A0(gUnknown_3005E10.unk_14); + if (idx != 0) + { + r1 = 1 << sub_80F886C(idx); + if (Rfu.unk_ce6 == 0 && Rfu.unk_ce8 == 0) + { + Rfu.unk_ce5 = r1; + Rfu.unk_ce6 |= (r1 ^ idx); + Rfu.unk_ce8 = 1; + } + else + { + Rfu.unk_ce6 |= idx; + } + } + if (idx != gUnknown_3005E10.unk_14) + { + Rfu.unk_ce3 |= (idx ^ gUnknown_3005E10.unk_14); + Rfu.unk_ce4 = 2; + } + } + else if (sub_80F9800()->unk_0a_0 == 0x54) + { + rfu_REQ_disconnect(gUnknown_3005E10.unk_00); + rfu_waitREQComplete(); + } + sub_80FB564(gUnknown_3005E10.unk_14); + break; + case 0x12: + break; + case 0x13: + break; + case 0x14: + if (sub_80F9800()->unk_0a_0 != 0x45 && gUnknown_3005E10.unk_01 > 1) + { + r1 = 1 << sub_80F886C(gUnknown_3005E10.unk_14); + rfu_REQ_disconnect(gUnknown_3005E10.unk_00 ^ r1); + rfu_waitREQComplete(); + } + if (Rfu.unk_04 == 0xF) + Rfu.unk_04 = 0x10; + break; + case 0x20: + Rfu.unk_ccd = gUnknown_3005E10.unk_14; + break; + case 0x21: + break; + case 0x22: + Rfu.unk_c3e = gUnknown_3005E10.unk_14; + break; + case 0x23: + Rfu.unk_04 = 0x12; + if (Rfu.unk_ccf < 2) + { + Rfu.unk_ccf++; + CreateTask(sub_80FC028, 2); + } + else + { + sub_80FB9E4(2, a0); + } + break; + case 0x24: + Rfu.unk_04 = 0xD; + sub_80FB9E4(3, 0); + rfu_setRecvBuffer(0x10, Rfu.unk_c3e, Rfu.unk_c3f, 70); + break; + case 0x25: + sub_80FB9E4(2, a0); + break; + case 0x31: + if (gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14) + Rfu.unk_f0 = 1; + break; + case 0x32: + Rfu.unk_f0 = 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) + { + if (gReceivedRemoteLinkPlayers == 1) + { + Rfu.unk_ce2 &= ~(gUnknown_3005E10.unk_14); + if (Rfu.unk_ce2 == 0) + sub_80FB0E8(a0); + else + sub_80FB174(); + } + } + else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1) + { + sub_80FB0E8(a0); + sub_80FD760(0); + } + + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && gUnknown_3005E10.unk_07 == 0 && FuncIsActiveTask(sub_80F8B34) == TRUE) + Rfu.unk_04 = 0x11; + + sub_80FB9E4(2, a0); + break; + case 0x40: + Rfu.unk_ce3 = 0; + break; + case 0x42 ... 0x44: + break; + case 0xF3: + sub_80FB9E4(1, a0); + sub_80FB0E8(a0); + Rfu.unk_ef = 1; + break; + case 0xF0 ... 0xF2: + case 0xFF: + sub_80FB0E8(a0); + sub_80FB9E4(1, a0); + Rfu.unk_cdb = 0; + break; + } +} + +void sub_80FB9D0(void) +{ + Rfu.unk_ce4 = 2; +} + +void sub_80FB9E4(u8 a0, u16 a1) +{ + Rfu.unk_f1 = a0; + Rfu.unk_0a = a1; +} + +u8 sub_80FB9F4(void) +{ + return Rfu.unk_f1; +} + +bool32 sub_80FBA00(void) +{ + u32 var = sub_80FB9F4() - 1; + if (var < 2) + return TRUE; + else + return FALSE; +} + +bool32 sub_80FBA1C(void) +{ + return Rfu.unk_ce8; +} + +bool8 Rfu_IsMaster(void) +{ + return Rfu.unk_0c; +} + +void RFUVSync(void) +{ + LinkRfu_syncVBlank_(); +} + +void sub_80FBA44(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_0x1111; + sub_800B1F4(); + 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(); + sub_80FBB20(); + SetMainCallback2(sub_80FBB74); + } +} + +bool32 sub_80FBB0C(void) +{ + return FuncIsActiveTask(sub_80F8B34); +} + +void sub_80FBB20(void) +{ + if (!FuncIsActiveTask(nullsub_89)) + Rfu.unk_66 = CreateTask(nullsub_89, 0); +} + +void sub_80FBB4C(void) +{ + if (FuncIsActiveTask(nullsub_89) == TRUE) + DestroyTask(Rfu.unk_66); +} + +static void sub_80FBB74(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_80FBB8C(u32 a0) +{ + Rfu.unk_0c = 1; + sub_80FAF1C(); + sub_80FD430(sub_80FB184, NULL); + gUnknown_203ABF0 = gUnknown_843EBB4; + gUnknown_203ABF0.unk_02 = gUnknown_843EBCC[a0 - 1]; + sub_80F8E74(); +} + +void sub_80FBBD8(void) +{ + Rfu.unk_0c = 0; + sub_80FAF1C(); + sub_80FD430(sub_80FB37C, sub_80F8D20); + sub_80F8F10(); +} + +void sub_80FBC00(void) +{ + if (gQuestLogState == 2 || gQuestLogState == 3) + return; + Rfu.unk_0c = 2; + sub_80FAF1C(); + sub_80FD430(sub_80FB5EC, NULL); + gUnknown_203ABF0 = gUnknown_843EBB4; + gUnknown_203ABF0.unk_11 = 0; + gUnknown_203ABF0.unk_12 = 0x258; + Rfu.unk_67 = CreateTask(sub_80F8B34, 1); +} + +static u16 ReadU16(const void *ptr) +{ + const u8 *ptr_ = ptr; + return (ptr_[1] << 8) | (ptr_[0]); +} + +static u8 sub_80FBC70(const u8 *a0, u16 a1) +{ + 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) + { + ret = i; + if (gRfuLinkStatus->partner[i].slot != 0xFF) + break; + } + } + + return ret; +} + +static void sub_80FBCF8(u32 a0) +{ + rfu_REQ_disconnect(a0); + rfu_waitREQComplete(); + Rfu.unk_ce2 &= ~(a0); + rfu_clearSlot(1, Rfu.unk_cda); + rfu_UNI_setSendData(Rfu.unk_ce2, Rfu.unk_c87, 70); + Rfu.unk_cda = sub_80F886C(Rfu.unk_ce2); +} + +void sub_80FBD4C(const u8 *ptr, u16 a1) +{ + u8 var = sub_80FBC70(ptr, a1); + if (var != 0xFF) + sub_80FBCF8(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.unk_cde[i] == a0 && (Rfu.unk_ce2 >> i) & 1) + var |= 1 << i; + } + if (var) + sub_80FBE20(var, 2); + } +} + +static void sub_80FBDB8(u8 taskId) +{ + if (gSendCmd[0] == 0 && Rfu.unk_ce8 == 0) + { + sub_80F9D04(0xED00); + gSendCmd[1] = gTasks[taskId].data[0]; + gSendCmd[2] = gTasks[taskId].data[1]; + Rfu.playerCount -= gUnknown_843EC41[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 sub_80FBE80(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (sub_80F8EA4()) + { + u8 id = sub_80FBC70((u8*)data, ReadU16(&data[8])); + if (id != 0xFF) + { + if (gRfuLinkStatus->partner[id].slot != 0xFF) + { + Rfu.unk_c3d = id; + if (sub_80F8ECC()) + DestroyTask(taskId); + } + else if (sub_80F9800()->unk_0a_0 == 0x15 || sub_80F9800()->unk_0a_0 == 0x16) + { + data[15]++; + } + else + { + sub_80FB9E4(2, 0x7000); + DestroyTask(taskId); + } + } + else + { + data[15]++; + Rfu.unk_c3d = id; + } + } + else + { + data[15]++; + } + + if (data[15] > 240) + { + sub_80FB9E4(2, 0x7000); + DestroyTask(taskId); + } +} + +void sub_80FBF54(const u8 *src, u16 trainerId) +{ + u8 taskId; + s16 *data; + + Rfu.unk_f1 = 0; + taskId = CreateTask(sub_80FBE80, 3); + data = gTasks[taskId].data; + StringCopy((u8*)(data), src); + data[8] = trainerId; +} + +static bool32 sub_80FBF98(s16 a1, struct GFtgtGname *structPtr) +{ + if (sub_80F9800()->unk_0a_0 == 0x45) + { + if (structPtr->unk_0a_0 != 0x45) + return TRUE; + } + else if (structPtr->unk_0a_0 != 0x40) + { + return TRUE; + } + else if (a1 == 0x44) + { + struct GFtgtGname *structPtr2 = (struct GFtgtGname *)&Rfu.unk_104.gname; + if (structPtr2->species == SPECIES_EGG) + { + if (structPtr->species == structPtr2->species) + return FALSE; + else + return TRUE; + } + else if (structPtr->species != structPtr2->species + || structPtr->level != structPtr2->level + || structPtr->type != structPtr2->type) + { + return TRUE; + } + } + + return FALSE; +} + +static void sub_80FC028(u8 taskId) +{ + if (Rfu.unk_f1 == 4) + DestroyTask(taskId); + + if (++gTasks[taskId].data[0] > 300) + { + sub_80FB9E4(2, 0x7000); + DestroyTask(taskId); + } + + if (Rfu.unk_ccd != 0 && gUnknown_3005E10.unk_06 == 0) + { + u16 trainerId = ReadU16(((struct GFtgtGname *)&Rfu.unk_104.gname)->unk_00.playerTrainerId); + u8 id = sub_80FBC70(Rfu.unk_104.uname, trainerId); + if (id != 0xFF) + { + if (!sub_80FBF98(gTasks[taskId].data[1], (struct GFtgtGname *)&gRfuLinkStatus->partner[id].gname)) + { + if (gRfuLinkStatus->partner[id].slot != 0xFF && !sub_80FD610(gRfuLinkStatus->partner[id].id, 0x5A)) + { + Rfu.unk_04 = 0xA; + DestroyTask(taskId); + } + } + else + { + sub_80FB9E4(2, 0x7000); + DestroyTask(taskId); + } + } + } +} + +void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2) +{ + u8 taskId, taskId2; + + Rfu.unk_ccf = 0; + Rfu.unk_f1 = 0; + StringCopy(Rfu.unk_104.uname, name); + memcpy(Rfu.unk_104.gname, structPtr, RFU_GAME_NAME_LENGTH); + sub_80FEB3C(); + taskId = CreateTask(sub_80FC028, 2); + gTasks[taskId].data[1] = a2; + taskId2 = FindTaskIdByFunc(sub_80F8B34); + if (a2 == 0x45) + { + if (taskId2 != 0xFF) + gTasks[taskId2].data[7] = 1; + } + else + { + if (taskId2 != 0xFF) + gTasks[taskId2].data[7] = 0; + } +} + +bool8 sub_80FC1B0(void) +{ + if (Rfu.unk_f0 == 1) + return TRUE; + else + return FALSE; +} + +bool32 sub_80FC1CC(void) +{ + s32 i; + + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if ((gUnknown_3005E10.unk_00 >> i) & 1 && Rfu.unk_cd1[i] == 0) + return FALSE; + } + + return TRUE; +} + +static void sub_80FC208(void) +{ + s32 i; + + for (i = 0; i < 20; i++) + nullsub_87(" ", 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 sub_80FC228(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) + { + 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); + } + } + 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); + } + } + nullsub_87("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); + } + 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); + } + else + { + for (i = 0; i < gRfuLinkStatus->findParentCount; i++) + { + 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); + } + } + 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); + } + } +} + +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 sub_80FC44C(void) +{ + return Rfu.unk_9e8.unk_232; +} + +u32 GetRfuRecvQueueLength(void) +{ + return Rfu.unk_124.unk_8c2; +} + +static void nullsub_89(u8 taskId) +{ + +} diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c new file mode 100644 index 000000000..01f19d817 --- /dev/null +++ b/src/link_rfu_3.c @@ -0,0 +1,948 @@ +#include "global.h" +#include "decompress.h" +#include "event_data.h" +#include "link.h" +#include "link_rfu.h" +#include "malloc.h" +#include "random.h" +#include "string_util.h" +#include "text.h" +#include "constants/flags.h" + +static EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0; + +static const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal"); + +static const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz"); + +static const u8 sWireless_ASCIItoRSETable[] = { + 0xff, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x37, + 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x00, 0xab, 0xb5, 0xb6, 0xb1, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xb2, 0xf1, 0x00, 0xae, 0xad, 0xba, + 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, + 0xa9, 0xaa, 0x00, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, + 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, + 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, + 0xd2, 0xd3, 0xd4, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, + 0x00, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, + 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, + 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, + 0xec, 0xed, 0xee, 0x2d, 0x2f, 0x30, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x50, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, + 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, + 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, + 0x1b, 0xad, 0xb3, 0xb4, 0x00, 0xaf, 0x7d, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xa0, + 0xae, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7e, 0xb0, 0xac, + 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, + 0x2c, 0x2e, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, + 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94 +}; + +static const u8 sWireless_RSEtoASCIITable[] = { + 0x20, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, + 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, + 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, + 0x9d, 0x9e, 0x9f, 0xa0, 0xe0, 0xe1, 0xe2, 0xe3, + 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, + 0xec, 0xed, 0xee, 0xef, 0xf0, 0x7b, 0xf1, 0x7c, + 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x84, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, + 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, + 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, + 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xa6, 0xdd, 0xa7, + 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xf2, + 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, + 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0xaf, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, + 0x37, 0x38, 0x39, 0x21, 0xdf, 0xa1, 0xb0, 0xa5, + 0xde, 0x24, 0x2a, 0xa2, 0xa3, 0x22, 0x23, 0x20, + 0xa4, 0x20, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, + 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, + 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, + 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, + 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, + 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, + 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x20, + 0x20, 0x2b, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00 +}; + +static const struct OamData sWirelessStatusIndicatorOamData = + { + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 0, + .paletteNum = 0, + }; + +static const union AnimCmd sWirelessStatusIndicatorAnim0[] = { + // 3 bars + ANIMCMD_FRAME( 4, 5), + ANIMCMD_FRAME( 8, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(16, 10), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME( 8, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd sWirelessStatusIndicatorAnim1[] = { + // 2 bars + ANIMCMD_FRAME( 4, 5), + ANIMCMD_FRAME( 8, 5), + ANIMCMD_FRAME(12, 10), + ANIMCMD_FRAME( 8, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd sWirelessStatusIndicatorAnim2[] = { + // 1 bar + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd sWirelessStatusIndicatorAnim3[] = { + // searching + ANIMCMD_FRAME( 4, 10), + ANIMCMD_FRAME(20, 10), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd sWirelessStatusIndicatorAnim4[] = { + // error + ANIMCMD_FRAME(24, 10), + ANIMCMD_FRAME( 4, 10), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const sWirelessStatusIndicatorAnims[] = { + sWirelessStatusIndicatorAnim0, + sWirelessStatusIndicatorAnim1, + sWirelessStatusIndicatorAnim2, + sWirelessStatusIndicatorAnim3, + sWirelessStatusIndicatorAnim4 +}; + +static const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = { + gWirelessLinkIconPic, 0x0380, 0xD431 +}; + +static const struct SpritePalette sWirelessStatusIndicatorSpritePalette = { + gWirelessLinkIconPalette, 0xD432 +}; + +static const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = { + 0xD431, + 0xD432, + &sWirelessStatusIndicatorOamData, + sWirelessStatusIndicatorAnims, + NULL, + gDummySpriteAffineAnimTable, + SpriteCallbackDummy +}; + +void sub_80FC478(struct UnkRfuStruct_2_Sub_124 *ptr) +{ + s32 i; + s32 j; + + for (i = 0; i < 20; i++) + { + for (j = 0; j < 70; j++) + { + ptr->unk_00[i][j] = 0; + } + } + ptr->unk_8c1 = 0; + ptr->unk_8c0 = 0; + ptr->unk_8c2 = 0; + ptr->unk_8c3 = 0; +} + +void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr) +{ + s32 i; + s32 j; + + for (i = 0; i < 40; i++) + { + for (j = 0; j < 14; j++) + { + ptr->unk_00[i][j] = 0; + } + } + ptr->unk_231 = 0; + ptr->unk_230 = 0; + ptr->unk_232 = 0; + ptr->unk_233 = 0; +} + +static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr) +{ + s32 i; + s32 j; + + for (i = 0; i < 2; i++) + { + for (j = 0; j < 256; j++) + { + ptr->unk_00[i][j] = 0; + } + } + ptr->unk_201 = 0; + ptr->unk_200 = 0; + ptr->unk_202 = 0; + ptr->unk_203 = 0; +} + +void sub_80FC588(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2) +{ + s32 i; + u16 imeBak; + u8 count; + + if (q1->unk_8c2 < 20) + { + imeBak = REG_IME; + REG_IME = 0; + count = 0; + for (i = 0; i < 70; i += 14) + { + if (q2[i] == 0 && q2[i + 1] == 0) + { + count++; + } + } + if (count != 5) + { + for (i = 0; i < 70; i++) + { + q1->unk_00[q1->unk_8c0][i] = q2[i]; + } + q1->unk_8c0++; + q1->unk_8c0 %= 20; + q1->unk_8c2++; + for (i = 0; i < 70; i++) + { + q2[i] = 0; + } + } + REG_IME = imeBak; + } + else + { + q1->unk_8c3 = 1; + } +} + +void sub_80FC63C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) +{ + s32 i; + u16 imeBak; + + if (q1->unk_232 < 40) + { + imeBak = REG_IME; + REG_IME = 0; + for (i = 0; i < 14; i++) + { + if (q2[i] != 0) + { + break; + } + } + if (i != 14) + { + for (i = 0; i < 14; i++) + { + q1->unk_00[q1->unk_230][i] = q2[i]; + } + q1->unk_230++; + q1->unk_230 %= 40; + q1->unk_232++; + for (i = 0; i < 14; i++) + { + q2[i] = 0; + } + } + REG_IME = imeBak; + } + else + { + q1->unk_233 = 1; + } +} + +bool8 sub_80FC6E8(struct UnkRfuStruct_2_Sub_124 *q1, u8 *q2) +{ + u16 imeBak; + s32 i; + + imeBak = REG_IME; + REG_IME = 0; + if (q1->unk_8c0 == q1->unk_8c1 || q1->unk_8c3 != 0) + { + for (i = 0; i < 70; i++) + { + q2[i] = 0; + } + REG_IME = imeBak; + return FALSE; + } + for (i = 0; i < 70; i++) + { + q2[i] = q1->unk_00[q1->unk_8c1][i]; + } + q1->unk_8c1++; + q1->unk_8c1 %= 20; + q1->unk_8c2--; + REG_IME = imeBak; + return TRUE; +} + +bool8 sub_80FC79C(struct UnkRfuStruct_2_Sub_9e8 *q1, u8 *q2) +{ + s32 i; + u16 imeBak; + + if (q1->unk_230 == q1->unk_231 || q1->unk_233 != 0) + { + return FALSE; + } + imeBak = REG_IME; + REG_IME = 0; + for (i = 0; i < 14; i++) + { + q2[i] = q1->unk_00[q1->unk_231][i]; + } + q1->unk_231++; + q1->unk_231 %= 40; + q1->unk_232--; + REG_IME = imeBak; + return TRUE; +} + +void sub_80FC828(struct UnkRfuStruct_2_Sub_c1c *q1, const u8 *q2) +{ + s32 i; + + if (q2[1] == 0) + { + sub_80FC888(q1, NULL); + } + else + { + for (i = 0; i < 14; i++) + { + q1->unk_00[q1->unk_1c][i] = q2[i]; + } + q1->unk_1c++; + q1->unk_1c %= 2; + if (q1->unk_1e < 2) + { + q1->unk_1e++; + } + else + { + q1->unk_1d = q1->unk_1c; + } + } +} + +bool8 sub_80FC888(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2) +{ + s32 i; + + if (q1->unk_1e == 0) + { + return FALSE; + } + if (q2 != NULL) + { + for (i = 0; i < 14; i++) + { + q2[i] = q1->unk_00[q1->unk_1d][i]; + } + } + q1->unk_1d++; + q1->unk_1d %= 2; + q1->unk_1e--; + return TRUE; +} + +static void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +{ + s32 i; + + if (q1->unk_202 < 2) + { + for (i = 0; i < 256; i++) + { + q1->unk_00[q1->unk_200][i] = q2[i]; + } + q1->unk_200++; + q1->unk_200 %= 2; + q1->unk_202++; + } + else + { + q1->unk_203 = 1; + } +} + +static bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +{ + s32 i; + + if (q1->unk_200 == q1->unk_201 || q1->unk_203) + { + return FALSE; + } + for (i = 0; i < 256; i++) + { + q2[i] = q1->unk_00[q1->unk_201][i]; + } + q1->unk_201++; + q1->unk_201 %= 2; + q1->unk_202--; + return TRUE; +} + +static void sub_80FC9B8(u8 *q1, u8 mode) +{ + s32 i; + u8 rval; + u16 r5 = 0; + static u8 _3002018; + + switch (mode) + { + case 0: + for (i = 0; i < 200; i++) + { + q1[i] = i + 1; + r5 += i + 1; + } + *((u16 *)(q1 + i)) = r5; + break; + case 1: + for (i = 0; i < 100; i++) + { + q1[i] = i + 1; + r5 += i + 1; + } + *((u16 *)(q1 + 200)) = r5; + break; + case 2: + for (i = 0; i < 200; i++) + { + rval = Random(); + q1[i] = rval; + r5 += rval; + } + *((u16 *)(q1 + i)) = r5; + break; + case 3: + for (i = 0; i < 200; i++) + { + q1[i] = i + 1 + _3002018; + r5 += (i + 1 + _3002018) & 0xFF; + } + *((u16 *)(q1 + i)) = r5; + _3002018++; + break; + } +} + +static void PkmnStrToASCII(u8 *q1, const u8 *q2) +{ + s32 i; + + for (i = 0; q2[i] != EOS; i++) + { + q1[i] = sWireless_RSEtoASCIITable[q2[i]]; + } + q1[i] = 0; +} + +static void ASCIIToPkmnStr(u8 *q1, const u8 *q2) +{ + s32 i; + + for (i = 0; q2[i] != 0; i++) + { + q1[i] = sWireless_ASCIItoRSETable[q2[i]]; + } + q1[i] = EOS; +} + +#ifdef NONMATCHING +static u8 sub_80FCADC(u8 maxFlags) +{ + u8 flagCount = 0; + u8 flags = gRfuLinkStatus->connSlotFlag; + u8 i; + + if (gRfuLinkStatus->parentChild == MODE_PARENT) + { + for (i = 0; i < 4; flags >>= 1, i++) + { + if (flags & 1) + { + if (maxFlags == flagCount + 1) + return gRfuLinkStatus->strength[i]; + flagCount++; + } + } + return 0; + } + else + { + for (i = 0; i < 4; flags >>= 1, i++) + { + if (flags & 1) + return gRfuLinkStatus->strength[i]; + } + return 0; + } +} +#else +NAKED +static u8 sub_80FCADC(u8 maxFlags) +{ + asm_unified("\tpush {r4-r7,lr}\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tmovs r6, 0\n" + "\tldr r0, _080FCB04 @ =gRfuLinkStatus\n" + "\tldr r4, [r0]\n" + "\tldrb r2, [r4, 0x2]\n" + "\tldrb r1, [r4]\n" + "\tadds r7, r0, 0\n" + "\tcmp r1, 0x1\n" + "\tbne _080FCB32\n" + "\tmovs r3, 0\n" + "\tands r1, r2\n" + "\tcmp r1, 0\n" + "\tbeq _080FCB0E\n" + "\tcmp r5, 0x1\n" + "\tbne _080FCB08\n" + "\tldrb r0, [r4, 0xA]\n" + "\tb _080FCB4C\n" + "\t.align 2, 0\n" + "_080FCB04: .4byte gRfuLinkStatus\n" + "_080FCB08:\n" + "\tadds r0, r6, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r6, r0, 24\n" + "_080FCB0E:\n" + "\tlsrs r2, 1\n" + "\tadds r0, r3, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r3, r0, 24\n" + "\tcmp r3, 0x3\n" + "\tbhi _080FCB4A\n" + "\tmovs r0, 0x1\n" + "\tands r0, r2\n" + "\tcmp r0, 0\n" + "\tbeq _080FCB0E\n" + "\tadds r0, r6, 0x1\n" + "\tcmp r5, r0\n" + "\tbne _080FCB08\n" + "_080FCB28:\n" + "\tldr r0, [r7]\n" + "\tadds r0, 0xA\n" + "\tadds r0, r3\n" + "\tldrb r0, [r0]\n" + "\tb _080FCB4C\n" + "_080FCB32:\n" + "\tmovs r3, 0\n" + "\tmovs r1, 0x1\n" + "_080FCB36:\n" + "\tadds r0, r2, 0\n" + "\tands r0, r1\n" + "\tcmp r0, 0\n" + "\tbne _080FCB28\n" + "\tlsrs r2, 1\n" + "\tadds r0, r3, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r3, r0, 24\n" + "\tcmp r3, 0x3\n" + "\tbls _080FCB36\n" + "_080FCB4A:\n" + "\tmovs r0, 0\n" + "_080FCB4C:\n" + "\tpop {r4-r7}\n" + "\tpop {r1}\n" + "\tbx r1"); +} +#endif + +void sub_80FCB54(struct GFtgtGname *data, u8 r9, bool32 r2, s32 r3) +{ + s32 i; + + for (i = 0; i < 2; i++) + { + data->unk_00.playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i]; + } + for (i = 0; i < RFU_CHILD_MAX; i++) + { + data->unk_04[i] = r3; + r3 >>= 8; + } + data->playerGender = gSaveBlock2Ptr->playerGender; + data->unk_0a_0 = r9; + 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->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 *buff1, u8 *buff2, u8 idx) +{ + bool8 retVal; + + if (gUnknown_3005E10.unk_06 == 1) + { + retVal = TRUE; + if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo) && ((gRfuLinkStatus->getNameFlag >> idx) & 1)) + { + memcpy(buff1, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); + memcpy(buff2, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); + } + else + { + memset(buff1, 0, RFU_GAME_NAME_LENGTH); + memset(buff2, 0, RFU_USER_NAME_LENGTH); + } + } + else + { + retVal = FALSE; + if (sub_80FA44C(gRfuLinkStatus->partner[idx].serialNo)) + { + memcpy(buff1, &gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); + memcpy(buff2, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); + } + else + { + memset(buff1, 0, RFU_GAME_NAME_LENGTH); + memset(buff2, 0, RFU_USER_NAME_LENGTH); + } + } + return retVal; +} + +bool8 sub_80FCCF4(struct GFtgtGname *buff1, u8 *buff2, u8 idx) +{ + bool8 retVal = FALSE; + if (gRfuLinkStatus->partner[idx].serialNo == 0x7F7D) + { + memcpy(buff1, gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); + memcpy(buff2, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); + retVal = TRUE; + } + else + { + memset(buff1, 0, RFU_GAME_NAME_LENGTH); + memset(buff2, 0, RFU_USER_NAME_LENGTH); + } + return retVal; +} + +void sub_80FCD50(struct GFtgtGname *buff1, u8 *buff2) +{ + memcpy(buff1, &gUnknown_3005440, RFU_GAME_NAME_LENGTH); + memcpy(buff2, gUnknown_3005E00, RFU_USER_NAME_LENGTH); +} + +void CreateWirelessStatusIndicatorSprite(u8 x, u8 y) +{ + u8 sprId; + + if (x == 0 && y == 0) + { + x = 0xE7; + y = 0x08; + } + if (gRfuLinkStatus->parentChild == MODE_PARENT) + { + sprId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0); + gSprites[sprId].data[7] = 0x1234; + gSprites[sprId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag); + gSprites[sprId].invisible = TRUE; + gWirelessStatusIndicatorSpriteId = sprId; + } + else + { + gWirelessStatusIndicatorSpriteId = CreateSprite(&sWirelessStatusIndicatorSpriteTemplate, x, y, 0); + gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0x1234; + gSprites[gWirelessStatusIndicatorSpriteId].data[6] = GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag); + gSprites[gWirelessStatusIndicatorSpriteId].invisible = TRUE; + } +} + +void DestroyWirelessStatusIndicatorSprite(void) +{ + if (gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234) + { + gSprites[gWirelessStatusIndicatorSpriteId].data[7] = 0; + DestroySprite(&gSprites[gWirelessStatusIndicatorSpriteId]); + gMain.oamBuffer[125] = gDummyOamData; + CpuCopy16(&gDummyOamData, (struct OamData *)OAM + 125, sizeof(struct OamData)); + } +} + +void LoadWirelessStatusIndicatorSpriteGfx(void) +{ + if (GetSpriteTileStartByTag(sWirelessStatusIndicatorSpriteSheet.tag) == 0xFFFF) + { + LoadCompressedSpriteSheet(&sWirelessStatusIndicatorSpriteSheet); + } + LoadSpritePalette(&sWirelessStatusIndicatorSpritePalette); + gWirelessStatusIndicatorSpriteId = 0xFF; +} + +static u8 sub_80FCEE4(void) +{ + u8 i; + u8 flags = gRfuLinkStatus->connSlotFlag; + for (i = 0; i < RFU_CHILD_MAX; i++) + { + if (flags & 1) + { + return gRfuLinkStatus->strength[i]; + } + flags >>= 1; + } + return 0; +} + +static void sub_80FCF1C(struct Sprite *sprite, s32 signalStrengthAnimNum) +{ + if (sprite->data[2] != signalStrengthAnimNum) + { + sprite->data[2] = signalStrengthAnimNum; + sprite->data[3] = 0; + sprite->data[4] = 0; + } +} + +void sub_80FCF34(void) +{ + if (gWirelessStatusIndicatorSpriteId != 0xFF && gSprites[gWirelessStatusIndicatorSpriteId].data[7] == 0x1234) + { + struct Sprite *sprite = &gSprites[gWirelessStatusIndicatorSpriteId]; + u8 signalStrength = 255; + u8 i = 0; + if (gRfuLinkStatus->parentChild == MODE_PARENT) + { + for (i = 0; i < GetLinkPlayerCount() - 1; i++) + { + if (signalStrength >= sub_80FCADC(i + 1)) + { + signalStrength = sub_80FCADC(i + 1); + } + } + } + else + { + signalStrength = sub_80FCEE4(); + } + if (sub_80FC1B0() == TRUE) + { + sprite->data[0] = 4; + } + else if (signalStrength < 25) + { + sprite->data[0] = 3; + } + else if (signalStrength >= 25 && signalStrength < 127) + { + sprite->data[0] = 2; + } + else if (signalStrength >= 127 && signalStrength < 229) + { + sprite->data[0] = 1; + } + else if (signalStrength >= 229) + { + sprite->data[0] = 0; + } + if (sprite->data[0] != sprite->data[1]) + { + sub_80FCF1C(sprite, sprite->data[0]); + sprite->data[1] = sprite->data[0]; + } + if (sprite->anims[sprite->data[2]][sprite->data[4]].frame.duration < sprite->data[3]) + { + sprite->data[4]++; + sprite->data[3] = 0; + if (sprite->anims[sprite->data[2]][sprite->data[4]].type == -2) + { + sprite->data[4] = 0; + } + } + else + { + sprite->data[3]++; + } + gMain.oamBuffer[125] = sWirelessStatusIndicatorOamData; + gMain.oamBuffer[125].x = sprite->pos1.x + sprite->centerToCornerVecX; + gMain.oamBuffer[125].y = sprite->pos1.y + sprite->centerToCornerVecY; + 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) + { + DestroyWirelessStatusIndicatorSprite(); + } + } +} + +static void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 *name) +{ + int i; + dest->trainerId = trainerId; + for (i = 0; i < 7; i++) + { + if (name[i] == EOS) + break; + dest->trainerName[i] = name[i]; + } + dest->trainerName[i] = EOS; +} + +static void ZeroName(u8 *name) +{ + s32 i; + + for (i = 0; i < PLAYER_NAME_LENGTH; i++) + { + *name++ = 0; + } +} + +static bool32 NameIsEmpty(const u8 *name) +{ + s32 i; + + for (i = 0; i < PLAYER_NAME_LENGTH; i++) + { + if (*name++ != 0) + { + return FALSE; + } + } + return TRUE; +} + +// Save the currently connected players into the trainer records, shifting all previous records down. +void RecordMixTrainerNames(void) +{ + if (gWirelessCommType != 0) + { + s32 i; + s32 j; + s32 nextSpace; + s32 connectedTrainerRecordIndices[5]; + struct TrainerNameRecord *newRecords = AllocZeroed(20 * sizeof(struct TrainerNameRecord)); + + // Check if we already have a record saved for connected trainers. + for (i = 0; i < GetLinkPlayerCount(); i++) + { + connectedTrainerRecordIndices[i] = -1; + for (j = 0; j < 20; j++) + { + if ((u16)gLinkPlayers[i].trainerId == gSaveBlock1Ptr->trainerNameRecords[j].trainerId && StringCompare(gLinkPlayers[i].name, gSaveBlock1Ptr->trainerNameRecords[j].trainerName) == 0) + { + connectedTrainerRecordIndices[i] = j; + } + } + } + + // Save the connected trainers first, at the top of the list. + nextSpace = 0; + for (i = 0; i < GetLinkPlayerCount(); i++) + { + if (i != GetMultiplayerId() && gLinkPlayers[i].language != LANGUAGE_JAPANESE) + { + CopyTrainerRecord(&newRecords[nextSpace], (u16)gLinkPlayers[i].trainerId, gLinkPlayers[i].name); + + // If we already had a record for this trainer, wipe it so that the next step doesn't duplicate it. + if (connectedTrainerRecordIndices[i] >= 0) + { + ZeroName(gSaveBlock1Ptr->trainerNameRecords[connectedTrainerRecordIndices[i]].trainerName); + } + nextSpace++; + } + } + + // Copy all non-empty records to the new list, in the order they appear on the old list. If the list is full, + // the last (oldest) records will be dropped. + for (i = 0; i < 20; i++) + { + if (!NameIsEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName)) + { + CopyTrainerRecord(&newRecords[nextSpace], gSaveBlock1Ptr->trainerNameRecords[i].trainerId, gSaveBlock1Ptr->trainerNameRecords[i].trainerName); + if (++nextSpace >= 20) + { + break; + } + } + } + + // Finalize the new list, and clean up. + memcpy(gSaveBlock1Ptr->trainerNameRecords, newRecords, 20 * sizeof(struct TrainerNameRecord)); + Free(newRecords); + } +} + +bool32 sub_80FD338(u16 id, u8 *name) +{ + s32 i; + + for (i = 0; i < 20; i++) + { + if (StringCompareN(gSaveBlock1Ptr->trainerNameRecords[i].trainerName, name, 7) == 0 && gSaveBlock1Ptr->trainerNameRecords[i].trainerId == id) + { + return TRUE; + } + if (NameIsEmpty(gSaveBlock1Ptr->trainerNameRecords[i].trainerName)) + { + return FALSE; + } + } + return FALSE; +} diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c index 6df5207f0..94c01c081 100644 --- a/src/mevent_server_helpers.c +++ b/src/mevent_server_helpers.c @@ -96,12 +96,12 @@ static bool32 mevent_receive_func(struct mevent_srv_sub * svr) svr->recvCRC = header.crc; if (svr->recvSize > ME_SEND_BUF_SIZE) { - sub_80FA190(); + LinkRfu_FatalError(); return FALSE; } else if (svr->recvIdent != header.ident) { - sub_80FA190(); + LinkRfu_FatalError(); return FALSE; } else @@ -133,7 +133,7 @@ static bool32 mevent_receive_func(struct mevent_srv_sub * svr) case 2: if (CalcCRC16WithTable(svr->recvBfr, svr->recvSize) != svr->recvCRC) { - sub_80FA190(); + LinkRfu_FatalError(); return FALSE; } else @@ -192,7 +192,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr) if (IsLinkTaskFinished()) { if (CalcCRC16WithTable(svr->sendBfr, svr->sendSize) != svr->sendCRC) - sub_80FA190(); + LinkRfu_FatalError(); else ++svr->seqno; } diff --git a/src/party_menu.c b/src/party_menu.c index a5ca78c06..d12a17e6c 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 UnkLinkRfuStruct_02022B14Substruct *)sub_80F9800(), species2, species, obedience)) + switch (CanRegisterMonForTradingBoard(*(struct GFtgtGnameSub *)sub_80F9800(), 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 UnkLinkRfuStruct_02022B14Substruct *)sub_80F9800(), gUnknown_203B064, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience); + u32 stringId = GetUnionRoomTradeMessageId(*(struct GFtgtGnameSub *)sub_80F9800(), gUnknown_203B064, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience); if (stringId != UR_TRADE_MSG_NONE) { diff --git a/src/trade.c b/src/trade.c index 10ed51d69..05a259e60 100644 --- a/src/trade.c +++ b/src/trade.c @@ -2763,7 +2763,7 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet) return FALSE; } -int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, struct UnkLinkRfuStruct_02022B14Substruct a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) +int GetUnionRoomTradeMessageId(struct GFtgtGnameSub a0, struct GFtgtGnameSub a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) { u8 r9 = a0.hasNationalDex; u8 r4 = a0.isChampion; @@ -2843,7 +2843,7 @@ int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, str return 0; } -int CanRegisterMonForTradingBoard(struct UnkLinkRfuStruct_02022B14Substruct a0, u16 species, u16 a2, u8 a3) +int CanRegisterMonForTradingBoard(struct GFtgtGnameSub a0, u16 species, u16 a2, u8 a3) { u8 canTradeEggAndNational = a0.hasNationalDex; |