From 11fd159ae811866fcbfdeb7ec558b5809dda9c50 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 11:17:38 -0500 Subject: Port link_rfu from Emerald --- src/link_rfu.c | 1383 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1383 insertions(+) create mode 100644 src/link_rfu.c (limited to 'src') diff --git a/src/link_rfu.c b/src/link_rfu.c new file mode 100644 index 000000000..37049e358 --- /dev/null +++ b/src/link_rfu.c @@ -0,0 +1,1383 @@ +#include "global.h" +#include "librfu.h" +#include "link_rfu.h" + +struct UnkRfuStruct_1 gUnknown_3005E10; + +void sub_80FD4E4(void); +void sub_80FDC28(u32 a0); +void sub_80FDC98(u16 reqCommandId, u16 reqResult); +void sub_80FE394(u16 reqCommandId); +void sub_80FE418(void); +void sub_80FE63C(void); +void sub_80FE6F0(void); +void sub_80FE74C(void); +u8 sub_80FE778(void); +void sub_80FE7F0(u8 a0, u8 a1); +void sub_80FE818(u8 bmDisconnectSlot); +void sub_80FE83C(u8 a0); +void sub_80FE918(void); +void sub_80FEAF4(void); +void sub_80FEB14(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 rfu_REQ_sendData_wrapper(u8 clockChangeFlag) +{ + if (gRfuLinkStatus->parentChild == MODE_CHILD) + { + if (gUnknown_3005E10.unk_02 == 1) + clockChangeFlag = 1; + else + clockChangeFlag = 0; + } + 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, offsetof(struct UnkRfuStruct_1, filler_48)); + 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; +} + +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; + } +} + +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; +} + +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); + } + } +} + +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 < 4; 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 == 1) + { + if (parentBmLinkRecoverySlot) + { + for (i = 0; i < 4; 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 < 4; 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 rfu_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 != 1 || !sub_80FD850(0)) + { + sub_80FE418(); + sub_80FE63C(); + sub_80FE74C(); + sub_80FE918(); + } + } +} + +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; + } +} + +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 < 4; 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 < 4; 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 < 4; 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(); + } +} + +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; +} + +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 < 4; 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 == 0x46) + { + 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; + } + } + } + } +} + +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 == 0x27) + { + 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); + } + } +} + +void sub_80FE6F0(void) +{ + if (gUnknown_3005E10.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == 0x26) + { + 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); + } +} + +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; + } +} + +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; +} + +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; +} + +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; +} + +void sub_80FE83C(u8 a0) +{ + u8 i; + + if (gRfuLinkStatus->sendSlotNIFlag) + { + for (i = 0; i < 4; i++) + { + if (gRfuSlotStatusNI[i]->send.state & 0x8000 && gRfuSlotStatusNI[i]->send.bmSlot & a0) + { + rfu_changeSendTarget(0x20, i, gRfuSlotStatusNI[i]->send.bmSlot & ~a0); + } + } + } + if (gRfuLinkStatus->recvSlotNIFlag) + { + for (i = 0; i < 4; i++) + { + if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && gRfuSlotStatusNI[i]->recv.bmSlot & a0) + { + rfu_NI_stopReceivingData(i); + } + } + } + if (gRfuLinkStatus->sendSlotUNIFlag) + { + gRfuLinkStatus->sendSlotUNIFlag &= ~a0; + for (i = 0; i < 4; i++) + { + if (gRfuSlotStatusUNI[i]->send.state == 0x8024 && a0 & gRfuSlotStatusUNI[i]->send.bmSlot) + { + gRfuSlotStatusUNI[i]->send.bmSlot &= ~a0; + } + } + } +} + +void sub_80FE918(void) +{ + u8 i; + u8 j; + u8 flags; + + if (gUnknown_3005E10.unk_18) + { + if (gRfuLinkStatus->sendSlotNIFlag) + { + for (i = 0; i < 4; i ++) + { + if (gRfuSlotStatusNI[i]->send.state & 0x8000) + { + flags = 0; + for (j = 0; j < 4; 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 < 4; i++) + { + if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && 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); +} + +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; +} + +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; +} + +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; +} + +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; + } + } +} + -- cgit v1.2.3 From 28a2bb7c934893cdc22cc617f83dcef033875801 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 11:21:55 -0500 Subject: Remove unneeded filler --- src/link_rfu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/link_rfu.c b/src/link_rfu.c index 37049e358..89b5c0924 100644 --- a/src/link_rfu.c +++ b/src/link_rfu.c @@ -59,7 +59,7 @@ s32 sub_80FD430(void (*func1)(u8, u8), void (*func2)(u16)) { return 4; } - CpuFill16(0, &gUnknown_3005E10, offsetof(struct UnkRfuStruct_1, filler_48)); + CpuFill16(0, &gUnknown_3005E10, sizeof(struct UnkRfuStruct_1)); gUnknown_3005E10.unk_06 = -1; gUnknown_3005E10.unk_40 = func1; gUnknown_3005E10.unk_44 = func2; -- cgit v1.2.3 From 6daa05332016d1410036f465f317ce463c5a3ac6 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 11:25:42 -0500 Subject: Static syms --- src/link_rfu.c | 69 +++++++++++++++++++++++++++++----------------------------- 1 file changed, 34 insertions(+), 35 deletions(-) (limited to 'src') diff --git a/src/link_rfu.c b/src/link_rfu.c index 89b5c0924..67fc338ef 100644 --- a/src/link_rfu.c +++ b/src/link_rfu.c @@ -4,21 +4,20 @@ struct UnkRfuStruct_1 gUnknown_3005E10; -void sub_80FD4E4(void); -void sub_80FDC28(u32 a0); -void sub_80FDC98(u16 reqCommandId, u16 reqResult); -void sub_80FE394(u16 reqCommandId); -void sub_80FE418(void); -void sub_80FE63C(void); -void sub_80FE6F0(void); -void sub_80FE74C(void); -u8 sub_80FE778(void); -void sub_80FE7F0(u8 a0, u8 a1); -void sub_80FE818(u8 bmDisconnectSlot); -void sub_80FE83C(u8 a0); -void sub_80FE918(void); -void sub_80FEAF4(void); -void sub_80FEB14(void); +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) { @@ -68,7 +67,7 @@ s32 sub_80FD430(void (*func1)(u8, u8), void (*func2)(u16)) return 0; } -void sub_80FD484(void) +static void sub_80FD484(void) { CpuFill16(0, &gUnknown_3005E10, offsetof(struct UnkRfuStruct_1, unk_40)); gUnknown_3005E10.unk_06 = -1; @@ -89,7 +88,7 @@ void sub_80FD4B0(const struct UnkLinkRfuStruct_02022B2C *unk0) } } -void sub_80FD4E4(void) +static void sub_80FD4E4(void) { u8 i; @@ -220,7 +219,7 @@ u8 sub_80FD610(u16 parentId, u16 unk_1a) return 0; } -void sub_80FD6F4(u8 lossSlot) +static void sub_80FD6F4(u8 lossSlot) { u8 i; @@ -326,7 +325,7 @@ void sub_80FD760(bool8 a0) } } -bool8 sub_80FD850(u16 reqCommandId) +static bool8 sub_80FD850(u16 reqCommandId) { bool8 retVal; u8 i; @@ -540,7 +539,7 @@ void sub_80FDA30(u32 a0) } } -void sub_80FDC28(u32 a0) +static void sub_80FDC28(u32 a0) { if (gUnknown_3005E10.unk_07 == 5) { @@ -580,7 +579,7 @@ void sub_80FDC28(u32 a0) } } -void sub_80FDC98(u16 r8, u16 r6) +static void sub_80FDC98(u16 r8, u16 r6) { u8 sp0; register u8 *stwiRecvBuffer asm("r0"); @@ -944,7 +943,7 @@ void sub_80FDC98(u16 r8, u16 r6) } } -void sub_80FE394(u16 reqCommandId) +static void sub_80FE394(u16 reqCommandId) { u8 r7; u8 ackFlag; @@ -983,7 +982,7 @@ void sub_80FE394(u16 reqCommandId) gUnknown_3005E10.unk_0e = r7; } -void sub_80FE418(void) +static void sub_80FE418(void) { u8 flags; u8 sp0; @@ -1101,7 +1100,7 @@ void sub_80FE418(void) } } -void sub_80FE63C(void) +static void sub_80FE63C(void) { u16 imeBak = REG_IME; REG_IME = 0; @@ -1133,7 +1132,7 @@ void sub_80FE63C(void) } } -void sub_80FE6F0(void) +static void sub_80FE6F0(void) { if (gUnknown_3005E10.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == 0x26) { @@ -1145,7 +1144,7 @@ void sub_80FE6F0(void) } } -void sub_80FE74C(void) +static void sub_80FE74C(void) { if (gUnknown_3005E10.unk_06 == 0 && gUnknown_3005E10.unk_0a == 1) { @@ -1157,7 +1156,7 @@ void sub_80FE74C(void) } } -u8 sub_80FE778(void) +static u8 sub_80FE778(void) { u8 i; const u16 *ptr; @@ -1176,7 +1175,7 @@ u8 sub_80FE778(void) return flags; } -void sub_80FE7F0(u8 a0, u8 a1) +static void sub_80FE7F0(u8 a0, u8 a1) { if (gUnknown_3005E10.unk_40 != NULL) { @@ -1185,7 +1184,7 @@ void sub_80FE7F0(u8 a0, u8 a1) gUnknown_3005E10.unk_14 = gUnknown_3005E10.unk_16 = 0; } -void sub_80FE818(u8 a0) +static void sub_80FE818(u8 a0) { u8 unk_0e_bak = gUnknown_3005E10.unk_0e; gUnknown_3005E10.unk_0e = 1; @@ -1194,7 +1193,7 @@ void sub_80FE818(u8 a0) gUnknown_3005E10.unk_0e = unk_0e_bak; } -void sub_80FE83C(u8 a0) +static void sub_80FE83C(u8 a0) { u8 i; @@ -1231,7 +1230,7 @@ void sub_80FE83C(u8 a0) } } -void sub_80FE918(void) +static void sub_80FE918(void) { u8 i; u8 j; @@ -1279,7 +1278,7 @@ void sub_80FEA10(void (*func)(u16)) rfu_setMSCCallback(sub_80FE394); } -void sub_80FEA28(void (*func)(u8, u8)) +static void sub_80FEA28(void (*func)(u8, u8)) { gUnknown_3005E10.unk_40 = func; } @@ -1299,7 +1298,7 @@ u8 sub_80FEA34(u8 a0, u16 a1) return 0; } -u8 sub_80FEA78(u16 a0) +static u8 sub_80FEA78(u16 a0) { if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag) { @@ -1311,7 +1310,7 @@ u8 sub_80FEA78(u16 a0) return 0; } -u8 sub_80FEAB4(u8 a0) +static u8 sub_80FEAB4(u8 a0) { if (gUnknown_3005E10.unk_04 == 9 || gUnknown_3005E10.unk_04 == 10 || gUnknown_3005E10.unk_04 == 11) { @@ -1330,7 +1329,7 @@ u8 sub_80FEAB4(u8 a0) return 0; } -void sub_80FEAF4(void) +static void sub_80FEAF4(void) { if (gUnknown_3005E10.unk_02) { -- cgit v1.2.3 From 2a5cde336bd55fdc07cf0293d36fb854c2313811 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 14:04:02 -0500 Subject: Address review comments --- src/librfu_rfu.c | 2 +- src/link_rfu.c | 55 +++++++++++++++++++++++++++---------------------------- 2 files changed, 28 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 96de99c2a..e178c91e4 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1533,7 +1533,7 @@ 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) { diff --git a/src/link_rfu.c b/src/link_rfu.c index 67fc338ef..195394cfe 100644 --- a/src/link_rfu.c +++ b/src/link_rfu.c @@ -38,14 +38,14 @@ u32 sub_80FD3A4(void) return id; } -void rfu_REQ_sendData_wrapper(u8 clockChangeFlag) +void LinkRfu_REQ_SendData_HandleParentRelationship(u8 clockChangeFlag) { if (gRfuLinkStatus->parentChild == MODE_CHILD) { - if (gUnknown_3005E10.unk_02 == 1) - clockChangeFlag = 1; + if (gUnknown_3005E10.unk_02 == TRUE) + clockChangeFlag = TRUE; else - clockChangeFlag = 0; + clockChangeFlag = FALSE; } else gUnknown_3005E10.unk_03 = 0; @@ -349,7 +349,7 @@ static bool8 sub_80FD850(u16 reqCommandId) } if (gUnknown_3005E10.unk_0a == 1) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((bmLinkLossSlot >> i) & 1) { @@ -375,11 +375,11 @@ static bool8 sub_80FD850(u16 reqCommandId) } sub_80FEAF4(); } - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) { if (parentBmLinkRecoverySlot) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gUnknown_3005E10.unk_30 >> i) & 1 && (parentBmLinkRecoverySlot >> i) & 1) { @@ -393,7 +393,7 @@ static bool8 sub_80FD850(u16 reqCommandId) if (gUnknown_3005E10.unk_30) { flags = 0; - for (i = 0; i < 4; i++) + 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) { @@ -529,7 +529,7 @@ void sub_80FDA30(u32 a0) gUnknown_3005E10.unk_0e = 0; } } while (gUnknown_3005E10.unk_04 == 18 || gUnknown_3005E10.unk_04 == 19); - if (gRfuLinkStatus->parentChild != 1 || !sub_80FD850(0)) + if (gRfuLinkStatus->parentChild != MODE_PARENT || !sub_80FD850(0)) { sub_80FE418(); sub_80FE63C(); @@ -733,7 +733,7 @@ static void sub_80FDC98(u16 r8, u16 r6) { 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 < 4; gUnknown_3005E10.unk_10 ++) + 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) { @@ -840,7 +840,7 @@ static void sub_80FDC98(u16 r8, u16 r6) if (gUnknown_3005E10.unk_30) { gUnknown_3005E10.unk_30 &= ~gUnknown_3005E10.unk_14; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gUnknown_3005E10.unk_14 >> i) & 1) { @@ -853,7 +853,7 @@ static void sub_80FDC98(u16 r8, u16 r6) } } sp0 = gUnknown_3005E10.unk_00 & gUnknown_3005E10.unk_14; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((sp0 >> i) & 1 && gUnknown_3005E10.unk_01) { @@ -1001,7 +1001,7 @@ static void sub_80FE418(void) sub_80FE7F0(0x10, 0x01); } sp0 = 0x00; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { r4 = 1 << i; r5 = 0x00; @@ -1012,7 +1012,7 @@ static void sub_80FE418(void) } else if (gUnknown_3005E10.unk_24 & r4) { - if (gRfuSlotStatusNI[i]->recv.state == 0x46) + if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS) { if (gRfuSlotStatusNI[i]->recv.dataType == 1) // Game identification information { @@ -1106,7 +1106,7 @@ static void sub_80FE63C(void) 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 == 0x27) + 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; @@ -1134,7 +1134,7 @@ static void sub_80FE63C(void) static void sub_80FE6F0(void) { - if (gUnknown_3005E10.unk_04 == 15 && gRfuSlotStatusNI[gUnknown_3005E10.unk_10]->send.state == 0x26) + 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); @@ -1199,9 +1199,9 @@ static void sub_80FE83C(u8 a0) if (gRfuLinkStatus->sendSlotNIFlag) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusNI[i]->send.state & 0x8000 && gRfuSlotStatusNI[i]->send.bmSlot & a0) + if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->send.bmSlot & a0) { rfu_changeSendTarget(0x20, i, gRfuSlotStatusNI[i]->send.bmSlot & ~a0); } @@ -1209,9 +1209,9 @@ static void sub_80FE83C(u8 a0) } if (gRfuLinkStatus->recvSlotNIFlag) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && gRfuSlotStatusNI[i]->recv.bmSlot & a0) + if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.bmSlot & a0) { rfu_NI_stopReceivingData(i); } @@ -1220,9 +1220,9 @@ static void sub_80FE83C(u8 a0) if (gRfuLinkStatus->sendSlotUNIFlag) { gRfuLinkStatus->sendSlotUNIFlag &= ~a0; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusUNI[i]->send.state == 0x8024 && a0 & gRfuSlotStatusUNI[i]->send.bmSlot) + if (gRfuSlotStatusUNI[i]->send.state == SLOT_STATE_SEND_UNI && a0 & gRfuSlotStatusUNI[i]->send.bmSlot) { gRfuSlotStatusUNI[i]->send.bmSlot &= ~a0; } @@ -1240,12 +1240,12 @@ static void sub_80FE918(void) { if (gRfuLinkStatus->sendSlotNIFlag) { - for (i = 0; i < 4; i ++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusNI[i]->send.state & 0x8000) + if (gRfuSlotStatusNI[i]->send.state & SLOT_BUSY_FLAG) { flags = 0; - for (j = 0; j < 4; j++) + for (j = 0; j < RFU_CHILD_MAX; j++) { if ((gRfuSlotStatusNI[i]->send.bmSlot >> j) & 1 && gRfuSlotStatusNI[j]->send.failCounter > gUnknown_3005E10.unk_18) { @@ -1261,9 +1261,9 @@ static void sub_80FE918(void) } if (gRfuLinkStatus->recvSlotNIFlag) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusNI[i]->recv.state & 0x8000 && gRfuSlotStatusNI[i]->recv.failCounter > gUnknown_3005E10.unk_18) + if (gRfuSlotStatusNI[i]->recv.state & SLOT_BUSY_FLAG && gRfuSlotStatusNI[i]->recv.failCounter > gUnknown_3005E10.unk_18) { rfu_NI_stopReceivingData(i); } @@ -1379,4 +1379,3 @@ void sub_80FEB3C(void) } } } - -- cgit v1.2.3 From fcf0e62d1f059c7161a6769e277afc7329260064 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 16:38:08 -0500 Subject: MODE_PARENT; collapse gUnknown_3005450 --> Rfu --- src/librfu_rfu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index e178c91e4..acaec8738 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1537,7 +1537,7 @@ 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) -- cgit v1.2.3 From 4602efe09198a19f8733a617184359abb9622d0a Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 16:38:55 -0500 Subject: clockChangeFlag is boolean --- src/librfu_rfu.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index acaec8738..dccd342f2 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1555,7 +1555,7 @@ void rfu_REQ_sendData(bool8 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(bool8 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(bool8 clockChangeFlag) STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); } } - if (clockChangeFlag != 0) + if (clockChangeFlag) { if (gRfuLinkStatus->parentChild == MODE_PARENT) { -- cgit v1.2.3 From 36306a82d131eee74c48e0ca6e66fff97dcffac2 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 20:40:47 -0500 Subject: link_rfu_2 through sub_80F8F5C --- src/link_rfu_2.c | 638 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 638 insertions(+) create mode 100644 src/link_rfu_2.c (limited to 'src') diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c new file mode 100644 index 000000000..80873ec60 --- /dev/null +++ b/src/link_rfu_2.c @@ -0,0 +1,638 @@ +#include "global.h" +#include "librfu.h" +#include "link.h" +#include "link_rfu.h" +#include "quest_log.h" +#include "task.h" + +struct UnkRfuStruct_2_Sub_6c +{ + /* 0x00 */ u16 unk_00; + /* 0x02 */ u16 unk_02; + /* 0x04 */ const u8 *unk_04; + /* 0x08 */ u32 unk_08; + /* 0x0c */ u32 unk_0c; + /* 0x10 */ u8 unk_10; + /* 0x11 */ u8 unk_11; + /* 0x12 */ u8 unk_12; +}; + +struct UnkRfuStruct_2_Sub_c1c +{ + /* 0x00 */ u8 unk_00[2][14]; + /* 0x1c */ vu8 unk_1c; + /* 0x1d */ vu8 unk_1d; + /* 0x1e */ vu8 unk_1e; +}; + +struct +{ + /* 0x000 */ void (*RfuFunc)(void); + /* 0x004 */ u16 unk_04; + /* 0x006 */ u8 filler_06[4]; + /* 0x00a */ u16 unk_0a; + /* 0x00c */ u8 unk_0c; + /* 0x00d */ u8 playerCount; + /* 0x00e */ u8 unk_0e; + /* 0x00f */ u8 unk_0f; + /* 0x010 */ u16 unk_10; + /* 0x012 */ u16 unk_12; + /* 0x014 */ u8 unk_14[4][14]; + /* 0x04c */ u8 unk_4c[14]; + /* 0x05a */ u8 unk_5a; + /* 0x05b */ u8 unk_5b; + /* 0x05c */ u8 unk_5c[5]; + /* 0x061 */ u8 unk_61[5]; + /* 0x066 */ u8 unk_66; + /* 0x067 */ u8 unk_67; + /* 0x068 */ u8 filler_68[4]; + /* 0x06c */ struct UnkRfuStruct_2_Sub_6c unk_6c; + /* 0x080 */ struct UnkRfuStruct_2_Sub_6c unk_80[5]; + /* 0x0e4 */ u8 unk_e4[5]; + /* 0x0e9 */ u8 unk_e9[5]; + /* 0x0ee */ vu8 unk_ee; + /* 0x0ef */ u8 unk_ef; + /* 0x0f0 */ u8 unk_f0; + /* 0x0f1 */ u8 unk_f1; + /* 0x0f2 */ u16 unk_f2[6]; + /* 0x0fe */ u16 unk_fe; + /* 0x100 */ u16 unk_100; + /* 0x102 */ u8 unk_102; + /* 0x103 */ u8 filler_103[0x10A - 0x103]; + /* 0x10A */ struct UnkLinkRfuStruct_02022B14 unk_10A; + /* 0x11B */ u8 filler_; + /* 0x11C */ u8 playerName[PLAYER_NAME_LENGTH]; + /* 0x124 */ struct UnkRfuStruct_2_Sub_124 unk_124; + /* 0x6a0 */ struct UnkRfuStruct_2_Sub_9e8 unk_9e8; + /* 0x8d4 */ struct UnkRfuStruct_2_Sub_c1c unk_c1c; + /* 0x8f4 */ vu8 unk_c3c; + /* 0x8f5 */ u8 unk_c3d; + /* 0x8f6 */ vu8 unk_c3e; + /* 0x8f7 */ u8 unk_c3f[70]; + /* 0x93d */ u8 unk_c85; + /* 0x93e */ u8 unk_c86; + /* 0x93f */ u8 unk_c87[5][7][2]; + /* 0x985 */ u8 unk_ccd; + /* 0x986 */ u8 unk_cce; + /* 0x987 */ u8 unk_ccf; + /* 0x988 */ vu8 unk_cd0; + /* 0x989 */ u8 unk_cd1[4]; + /* 0x98d */ u8 unk_cd5[4]; + /* 0x991 */ u8 unk_cd9; + /* 0x992 */ u8 unk_cda; + /* 0x993 */ vu8 unk_cdb; + /* 0x994 */ vu8 unk_cdc; + /* 0x995 */ u8 unk_cdd; + /* 0x996 */ u8 unk_cde[4]; + /* 0x99a */ u8 unk_ce2; + /* 0x99b */ u8 unk_ce3; + /* 0x99c */ u8 unk_ce4; + /* 0x99d */ u8 unk_ce5; + /* 0x99e */ u8 unk_ce6; + /* 0x99f */ u8 unk_ce7; + /* 0x9a0 */ u8 unk_ce8; + /* 0x9a1 */ u8 unk_ce9; + /* 0x9a2 */ u8 unk_cea[4]; + /* 0x9a6 */ u8 unk_cee[4]; +} Rfu; // size: 0x9AC + +EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_203ABF0 = {}; +EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; + +ALIGNED(8) IWRAM_DATA u8 gUnknown_3001188; +ALIGNED(8) IWRAM_DATA struct RfuAPIBuffer gRfuAPIBuffer; +ALIGNED(8) IWRAM_DATA u8 gUnknown_3001FF8[14]; +ALIGNED(8) IWRAM_DATA u16 gUnknown_3002008[7]; + +struct UnkLinkRfuStruct_02022B14 gUnknown_3005440; +u8 gUnknown_3005E00[PLAYER_NAME_LENGTH]; + +void sub_80F8AA4(void); +void sub_80F8AEC(void); +void sub_80F8D20(u16 a0); +void sub_80F8DA8(u16 a0); +void sub_80F906C(void); +void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data); +void sub_80FA738(void); +int sub_80FA788(void); +void sub_80FA834(u8 taskId); +void sub_80FAA94(u8 taskId); +void sub_80FACF0(u8 taskId); +void sub_80FAFE0(u8 a0); +void sub_80FC208(void); + +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 +}; + +const u8 gUnknown_843EBCC[] = { + 0, 3, 2, 1, 0 +}; + +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 +}; + +const u8 gUnknown_843EC38[] = { + 0, 0, 1, + 1, 2, 2, + 2, 2, 3 +}; + +const u8 gUnknown_843EC41[] = { + 0, 1, 1, 2, + 1, 2, 2, 3, + 1, 2, 2, 3, + 2, 3, 3, 4 +}; + +const u8 gUnknown_843EC51[] = { + 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 +}; + +const struct { + u8 *buffer; + u32 size; +} gUnknown_843EC64[] = { + { gBlockSendBuffer, 200 }, + { gBlockSendBuffer, 200 }, + { gBlockSendBuffer, 100 }, + { gBlockSendBuffer, 220 }, + { gBlockSendBuffer, 40 } +}; + +const u16 gUnknown_843EC8C[] = { + 0x0002, 0x7f7d, 0xFFFF +}; + +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" +}; + +const char sUnref_843ED37[][16] = { + " ", + "RECOVER START ", + "DISSCONECT ", + "RECOVER SUUSES", + "RECOVER FAILED" +}; + +const TaskFunc gUnknown_843ED88[] = { + sub_80FA834, + sub_80FAA94, + sub_80FACF0 +}; + +void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2) +{ + // debug? +} + +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); + } +} + +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; + } +} + +s32 sub_80F886C(u8 idx) +{ + return gUnknown_843EC51[idx]; +} + +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 < 4; r2 >>= 1, i++) + { + if (r2 & 1) + { + Rfu.unk_cde[i] = r4; + r4++; + } + } + } + else + { + for (i = 0; i < 4; r1 >>= 1, i++) + { + if (!(r1 & 1)) + { + Rfu.unk_cde[i] = 0; + } + } + for (r4 = 4; r4 != 0; r4--) + { + for (i = 0; i < 4 && Rfu.unk_cde[i] != r4; i++); + if (i == 4) + { + r6 = r4; + } + } + for (r5 &= ~r2, i = 0; i < 4; r5 >>= 1, i++) + { + if (r5 & 1) + { + Rfu.unk_cde[i] = r6++; + } + } + } +} + +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, 70); + rfu_UNI_setSendData(r5, Rfu.unk_4c, 14); + gTasks[taskId].data[1] = 8; + DestroyTask(taskId); + if (gUnknown_203AC08.unk_0f == 0) + { + sub_80FC208(); + gUnknown_203AC08.unk_0f++; + } + CreateTask(sub_80FA834, 5); + break; + } + } +} + +void sub_80F8AA4(void) +{ + u8 i; + u8 r5 = gUnknown_3005E10.unk_00; + for (i = 0; i < 4; i++) + { + if (r5 & 1) + { + rfu_setRecvBuffer(16, i, Rfu.unk_14[i], 14); + rfu_clearSlot(3, i); + } + r5 >>= 1; + } +} + +void sub_80F8AEC(void) +{ + u8 r5 = gUnknown_3005E10.unk_00; + rfu_UNI_setSendData(r5, Rfu.unk_c87, 70); + Rfu.unk_cda = sub_80F886C(r5); + Rfu.unk_ce2 = r5; + sub_80F887C(r5, -1); + Rfu.unk_0c = 1; +} + +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, 14) == 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); +} + +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); +} + +void sub_80F8DA8(u16 unused) +{ + Rfu.unk_cdb = 1; +} + +void sub_80F8DC0(void) +{ + u8 i; + + if (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 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 < 3; i++) + { + if (FuncIsActiveTask(gUnknown_843ED88[i]) == TRUE) + { + DestroyTask(FindTaskIdByFunc(gUnknown_843ED88[i])); + } + } +} + +void sub_80F8E74(void) +{ + if (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 3) + return; + Rfu.unk_67 = CreateTask(sub_80F8738, 1); +} + +bool8 sub_80F8EA4(void) +{ + if (Rfu.unk_04 == 7 && Rfu.unk_ccd) + { + return TRUE; + } + return FALSE; +} + +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; +} + +void sub_80F8F10(void) +{ + if (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 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; +} -- cgit v1.2.3 From d9ea5a08159ededd81fc0d8c33b0270b925081b6 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 13 Jan 2020 22:08:11 -0500 Subject: link_rfu_2 through rfufunc_80FA020 --- src/link_rfu_2.c | 711 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 702 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 80873ec60..5d8c26983 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -2,6 +2,7 @@ #include "librfu.h" #include "link.h" #include "link_rfu.h" +#include "overworld.h" #include "quest_log.h" #include "task.h" @@ -17,15 +18,7 @@ struct UnkRfuStruct_2_Sub_6c /* 0x12 */ u8 unk_12; }; -struct UnkRfuStruct_2_Sub_c1c -{ - /* 0x00 */ u8 unk_00[2][14]; - /* 0x1c */ vu8 unk_1c; - /* 0x1d */ vu8 unk_1d; - /* 0x1e */ vu8 unk_1e; -}; - -struct +struct UnkRfuStruct_2 { /* 0x000 */ void (*RfuFunc)(void); /* 0x004 */ u16 unk_04; @@ -112,13 +105,23 @@ void sub_80F8AEC(void); void sub_80F8D20(u16 a0); void sub_80F8DA8(u16 a0); void sub_80F906C(void); +void sub_80F9868(u8 unused); void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data); +void sub_80F9D04(u16 command); +void rfufunc_80F9F44(void); +void sub_80F9FA8(void); +void rfufunc_80FA020(void); +void sub_80FA510(void); void sub_80FA738(void); int sub_80FA788(void); void sub_80FA834(u8 taskId); +void sub_80FA9D0(u16 a0); +bool32 sub_80FAA58(void * a0); void sub_80FAA94(u8 taskId); void sub_80FACF0(u8 taskId); void sub_80FAFE0(u8 a0); +void sub_80FB0E8(u32 a0); +void sub_80FBCF8(u32 a0); void sub_80FC208(void); const struct UnkLinkRfuStruct_02022B2C gUnknown_843EBB4 = { @@ -636,3 +639,693 @@ 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; +} + +void sub_80F8FAC(u8 a0) +{ + u8 i; + + for (i = 0; i < 4; i++) + { + if (a0 & 1) + { + rfu_UNI_readySendData(i); + break; + } + a0 >>= 1; + } +} + +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); +} + +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; + } +} + +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; +} + +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; +} + +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 < 4; 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); + sub_80FA510(); + if (Rfu.unk_ce5 && !Rfu.unk_cd9) + { + gUnknown_203AC08.unk_0e = 0; + rfu_clearSlot(3, Rfu.unk_cda); + for (i = 0; i < 4; i++) + { + if ((Rfu.unk_ce5 >> i) & 1) + { + rfu_setRecvBuffer(0x10, i, Rfu.unk_14[i], 14); + } + } + 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, 70); + 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; +} + +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; + } +} + +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--; + sub_80FA510(); + sub_80F94BC(gSendCmd, sp48); + sub_80FC63C(&Rfu.unk_9e8, sp48); + for (i = 0; i < CMD_LENGTH - 1; i++) + gSendCmd[i] = 0; + } + return IsRfuRecvQueueEmpty(); +} + +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; +} + +u8 sub_80F9770(const u8 *a0) +{ + u8 i; + + if (Rfu.unk_0c == 1) + return FALSE; + for (i = 0; i < 4; i++) + { + Rfu.unk_cde[i] = a0[i]; + } + return a0[Rfu.unk_c3e]; +} + +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 UnkLinkRfuStruct_02022B14 *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; +} + +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]++; + } + } +} + +bool8 sub_80F9C50(void) +{ + s32 i; + + for (i = 0; i < 5; i++) + { + if (Rfu.unk_80[i].unk_12) + return FALSE; + } + return TRUE; +} + +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; +} + +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; +} + +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 < 4; 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; +} + +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; + } + } +} +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; + } +} + +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; +} -- cgit v1.2.3 From b76b38c257e36ce13b32f95ed726175efddb1478 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 12:27:56 -0500 Subject: Finish porting link_rfu_2 --- src/link_rfu_2.c | 1747 +++++++++++++++++++++++++++++++++++++++++-- src/mevent_server_helpers.c | 8 +- 2 files changed, 1671 insertions(+), 84 deletions(-) (limited to 'src') diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 5d8c26983..9baee37ed 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -1,10 +1,17 @@ #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_2_Sub_6c { @@ -24,7 +31,7 @@ struct UnkRfuStruct_2 /* 0x004 */ u16 unk_04; /* 0x006 */ u8 filler_06[4]; /* 0x00a */ u16 unk_0a; - /* 0x00c */ u8 unk_0c; + /* 0x00c */ u8 unk_0c; // parentChildMode? /* 0x00d */ u8 playerCount; /* 0x00e */ u8 unk_0e; /* 0x00f */ u8 unk_0f; @@ -66,7 +73,7 @@ struct UnkRfuStruct_2 /* 0x93e */ u8 unk_c86; /* 0x93f */ u8 unk_c87[5][7][2]; /* 0x985 */ u8 unk_ccd; - /* 0x986 */ u8 unk_cce; + /* 0x986 */ u8 unk_cce; // childId /* 0x987 */ u8 unk_ccf; /* 0x988 */ vu8 unk_cd0; /* 0x989 */ u8 unk_cd1[4]; @@ -87,44 +94,58 @@ struct UnkRfuStruct_2 /* 0x9a1 */ u8 unk_ce9; /* 0x9a2 */ u8 unk_cea[4]; /* 0x9a6 */ u8 unk_cee[4]; -} Rfu; // size: 0x9AC +}; // size: 0x9AC + +struct UnkRfuStruct_8010A14{ + char unk_00[15]; // PokemonSioInfo + u8 unk_0f; + u8 unk_10[4]; + struct LinkPlayer unk_14[5]; + u8 fill_a0[0x5c]; +}; -EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_203ABF0 = {}; -EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; +static EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_203ABF0 = {}; +static EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; -ALIGNED(8) IWRAM_DATA u8 gUnknown_3001188; -ALIGNED(8) IWRAM_DATA struct RfuAPIBuffer gRfuAPIBuffer; -ALIGNED(8) IWRAM_DATA u8 gUnknown_3001FF8[14]; -ALIGNED(8) IWRAM_DATA u16 gUnknown_3002008[7]; +static u8 gUnknown_3001188; +static struct RfuAPIBuffer gRfuAPIBuffer; +static u8 gUnknown_3001FF8[14]; +static u16 gUnknown_3002008[7]; struct UnkLinkRfuStruct_02022B14 gUnknown_3005440; +struct UnkRfuStruct_2 Rfu; u8 gUnknown_3005E00[PLAYER_NAME_LENGTH]; -void sub_80F8AA4(void); -void sub_80F8AEC(void); -void sub_80F8D20(u16 a0); -void sub_80F8DA8(u16 a0); -void sub_80F906C(void); -void sub_80F9868(u8 unused); -void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data); -void sub_80F9D04(u16 command); -void rfufunc_80F9F44(void); -void sub_80F9FA8(void); -void rfufunc_80FA020(void); -void sub_80FA510(void); -void sub_80FA738(void); -int sub_80FA788(void); -void sub_80FA834(u8 taskId); -void sub_80FA9D0(u16 a0); -bool32 sub_80FAA58(void * a0); -void sub_80FAA94(u8 taskId); -void sub_80FACF0(u8 taskId); -void sub_80FAFE0(u8 a0); -void sub_80FB0E8(u32 a0); -void sub_80FBCF8(u32 a0); -void sub_80FC208(void); - -const struct UnkLinkRfuStruct_02022B2C gUnknown_843EBB4 = { +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, @@ -138,11 +159,11 @@ const struct UnkLinkRfuStruct_02022B2C gUnknown_843EBB4 = { .unk_14 = 0x012c }; -const u8 gUnknown_843EBCC[] = { +static const u8 gUnknown_843EBCC[] = { 0, 3, 2, 1, 0 }; -const u32 gUnknown_843EBD4[] = { +static const u32 gUnknown_843EBD4[] = { 0x000000, 0x000001, 0x000003, @@ -170,24 +191,24 @@ const u32 gUnknown_843EBD4[] = { 0xffffff }; -const u8 gUnknown_843EC38[] = { +static const u8 gUnknown_843EC38[] = { 0, 0, 1, 1, 2, 2, 2, 2, 3 }; -const u8 gUnknown_843EC41[] = { +static const u8 gUnknown_843EC41[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; -const u8 gUnknown_843EC51[] = { +static const u8 gUnknown_843EC51[] = { 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 }; -const struct { +static const struct { u8 *buffer; u32 size; } gUnknown_843EC64[] = { @@ -198,11 +219,11 @@ const struct { { gBlockSendBuffer, 40 } }; -const u16 gUnknown_843EC8C[] = { +static const u16 gUnknown_843EC8C[] = { 0x0002, 0x7f7d, 0xFFFF }; -const char sUnref_843EC92[][15] = { +static const char sUnref_843EC92[][15] = { "RFU WAIT", "RFU BOOT", "RFU ERROR", @@ -216,7 +237,7 @@ const char sUnref_843EC92[][15] = { "RFU CP POLL" }; -const char sUnref_843ED37[][16] = { +static const char sUnref_843ED37[][16] = { " ", "RECOVER START ", "DISSCONECT ", @@ -224,18 +245,18 @@ const char sUnref_843ED37[][16] = { "RECOVER FAILED" }; -const TaskFunc gUnknown_843ED88[] = { +static const TaskFunc gUnknown_843ED88[] = { sub_80FA834, sub_80FAA94, sub_80FACF0 }; -void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2) +static void nullsub_87(const void *unused_0, u8 unused_1, u8 unused_2) { // debug? } -void nullsub_88(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3) +static void nullsub_88(u16 unused_0, u8 unused_1, u8 unused_2, u8 unused_3) { } @@ -287,7 +308,7 @@ void sub_80F86F4(void) } } -void sub_80F8738(u8 taskId) +static void sub_80F8738(u8 taskId) { sub_80FA738(); switch (Rfu.unk_04) @@ -325,12 +346,12 @@ void sub_80F8738(u8 taskId) } } -s32 sub_80F886C(u8 idx) +static u8 sub_80F886C(u8 idx) { return gUnknown_843EC51[idx]; } -void sub_80F887C(s32 r2, s32 r5) +static void sub_80F887C(s32 r2, s32 r5) { u8 i; u8 r4 = 1; @@ -374,7 +395,7 @@ void sub_80F887C(s32 r2, s32 r5) } } -void sub_80F893C(u8 taskId) +static void sub_80F893C(u8 taskId) { switch (Rfu.unk_04) { @@ -428,7 +449,7 @@ void sub_80F893C(u8 taskId) } } -void sub_80F8AA4(void) +static void sub_80F8AA4(void) { u8 i; u8 r5 = gUnknown_3005E10.unk_00; @@ -443,7 +464,7 @@ void sub_80F8AA4(void) } } -void sub_80F8AEC(void) +static void sub_80F8AEC(void) { u8 r5 = gUnknown_3005E10.unk_00; rfu_UNI_setSendData(r5, Rfu.unk_c87, 70); @@ -453,7 +474,7 @@ void sub_80F8AEC(void) Rfu.unk_0c = 1; } -void sub_80F8B34(u8 taskId) +static void sub_80F8B34(u8 taskId) { if (sub_80F9800()->unk_0a_0 == 0x54 && sub_80FB9F4() == 4) { @@ -524,7 +545,7 @@ void sub_80F8D14(void) sub_80FD760(FALSE); } -void sub_80F8D20(u16 unused) +static void sub_80F8D20(u16 unused) { s32 i; @@ -546,7 +567,7 @@ void sub_80F8D20(u16 unused) LinkRfu_REQ_SendData_HandleParentRelationship(TRUE); } -void sub_80F8DA8(u16 unused) +static void sub_80F8DA8(u16 unused) { Rfu.unk_cdb = 1; } @@ -592,14 +613,14 @@ void sub_80F8DC0(void) } } -void sub_80F8E74(void) +static void sub_80F8E74(void) { if (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 3) return; Rfu.unk_67 = CreateTask(sub_80F8738, 1); } -bool8 sub_80F8EA4(void) +static bool8 sub_80F8EA4(void) { if (Rfu.unk_04 == 7 && Rfu.unk_ccd) { @@ -608,7 +629,7 @@ bool8 sub_80F8EA4(void) return FALSE; } -bool32 sub_80F8ECC(void) +static bool32 sub_80F8ECC(void) { if (Rfu.unk_04 == 7 && !sub_80FD610(gRfuLinkStatus->partner[Rfu.unk_c3d].id, 240)) { @@ -618,7 +639,7 @@ bool32 sub_80F8ECC(void) return FALSE; } -void sub_80F8F10(void) +static void sub_80F8F10(void) { if (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 3) return; @@ -655,7 +676,7 @@ void sub_80F8FA0(void) Rfu.unk_04 = 14; } -void sub_80F8FAC(u8 a0) +static void sub_80F8FAC(u8 a0) { u8 i; @@ -670,7 +691,7 @@ void sub_80F8FAC(u8 a0) } } -void sub_80F8FD4(void) +static void sub_80F8FD4(void) { s32 i, j; @@ -686,7 +707,7 @@ void sub_80F8FD4(void) CpuFill16(0, gRecvCmds, sizeof gRecvCmds); } -void sub_80F9038(void) +static void sub_80F9038(void) { s32 i; for (i = 0; i < 7; i++) @@ -699,7 +720,7 @@ void sub_80F9038(void) } } -void sub_80F906C(void) +static void sub_80F906C(void) { if (Rfu.unk_c3c) { @@ -742,7 +763,7 @@ bool32 IsRfuRecvQueueEmpty(void) return TRUE; } -bool32 sub_80F911C(void) +static bool32 sub_80F911C(void) { if (Rfu.unk_04 < 20) { @@ -788,7 +809,7 @@ bool32 sub_80F911C(void) return FALSE; } -bool32 sub_80F9204(void) +static bool32 sub_80F9204(void) { u16 i; u16 flags; @@ -844,7 +865,7 @@ bool32 sub_80F9204(void) } sub_80F9038(); sub_80F9868(0); - sub_80FA510(); + CallRfuFunc(); if (Rfu.unk_ce5 && !Rfu.unk_cd9) { gUnknown_203AC08.unk_0e = 0; @@ -876,7 +897,7 @@ bool32 sub_80F9204(void) return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE; } -void sub_80F94BC(u16 *a0, u8 *a1) +static void sub_80F94BC(u16 *a0, u8 *a1) { s32 i; @@ -897,7 +918,7 @@ void sub_80F94BC(u16 *a0, u8 *a1) } } -bool32 sub_80F9514(void) +static bool32 sub_80F9514(void) { u8 i; u8 j; @@ -935,7 +956,7 @@ bool32 sub_80F9514(void) if (Rfu.unk_cd0) { Rfu.unk_cd0--; - sub_80FA510(); + CallRfuFunc(); sub_80F94BC(gSendCmd, sp48); sub_80FC63C(&Rfu.unk_9e8, sp48); for (i = 0; i < CMD_LENGTH - 1; i++) @@ -944,7 +965,7 @@ bool32 sub_80F9514(void) return IsRfuRecvQueueEmpty(); } -void sub_80F965C(u8 unused, u32 flags) +static void sub_80F965C(u8 unused, u32 flags) { s32 i, j; @@ -986,7 +1007,7 @@ void Rfu_ResetBlockReceivedFlag(u8 a0) Rfu.unk_80[a0].unk_12 = 0; } -u8 sub_80F9770(const u8 *a0) +static u8 sub_80F9770(const u8 *a0) { u8 i; @@ -999,7 +1020,7 @@ u8 sub_80F9770(const u8 *a0) return a0[Rfu.unk_c3e]; } -void rfu_func_080F97B8(void) +static void rfu_func_080F97B8(void) { // static u8 gUnknown_3001188; if (gReceivedRemoteLinkPlayers @@ -1033,7 +1054,7 @@ void Rfu_set_zero(void) Rfu.RfuFunc = NULL; } -void sub_80F9868(u8 unused) +static void sub_80F9868(u8 unused) { u16 i; u16 j; @@ -1138,7 +1159,7 @@ void sub_80F9868(u8 unused) } } -bool8 sub_80F9C50(void) +static bool8 sub_80F9C50(void) { s32 i; @@ -1150,7 +1171,7 @@ bool8 sub_80F9C50(void) return TRUE; } -bool8 sub_80F9C78(void) +static bool8 sub_80F9C78(void) { s32 i; @@ -1162,7 +1183,7 @@ bool8 sub_80F9C78(void) return TRUE; } -void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data) +static void sub_80F9CB4(struct UnkRfuStruct_2_Sub_6c *data) { data->unk_00 = 0; data->unk_02 = 0; @@ -1188,7 +1209,7 @@ u8 Rfu_GetBlockReceivedStatus(void) return flags; } -void sub_80F9D04(u16 command) +static void sub_80F9D04(u16 command) { u8 i; u8 *buff; @@ -1273,7 +1294,7 @@ bool32 Rfu_InitBlockSend(const u8 *src, size_t size) return TRUE; } -void rfufunc_80F9F44(void) +static void rfufunc_80F9F44(void) { if (gSendCmd[0] == 0) { @@ -1290,7 +1311,7 @@ void rfufunc_80F9F44(void) } } } -void sub_80F9FA8(void) +static void sub_80F9FA8(void) { s32 i; const u8 *src = Rfu.unk_6c.unk_04; @@ -1305,7 +1326,7 @@ void sub_80F9FA8(void) } } -void rfufunc_80FA020(void) +static void rfufunc_80FA020(void) { const u8 *src = Rfu.unk_6c.unk_04; u8 mpId = GetMultiplayerId(); @@ -1329,3 +1350,1569 @@ void rfufunc_80FA020(void) 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 == FALSE) + return sub_80FEA34(0, 0); + sub_80FEA34(1, 0x258); + return 0; +} + +void sub_80FA4A8(void) +{ + Rfu.unk_cd9 = 1; + sub_80FD760(FALSE); +} + +u8 rfu_get_multiplayer_id(void) +{ + if (Rfu.unk_0c == 1) + return 0; + return Rfu.unk_cce; +} + +u8 GetRfuPlayerCount(void) +{ + return Rfu.playerCount; +} + +bool8 IsLinkRfuTaskFinished(void) +{ + return Rfu.RfuFunc ? FALSE : TRUE; +} + +static void CallRfuFunc(void) +{ + if (Rfu.RfuFunc) + 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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, 0xD); + 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 < 4; 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 < 4; i++) + { + if ((gUnknown_3005E10.unk_14 >> i) & 1) + { + struct UnkLinkRfuStruct_02022B14 *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 < 4; 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 < 4; i++) + { + if ((a0 >> i) & 1) + { + struct UnkLinkRfuStruct_02022B14 *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) +{ + rfu_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 < 4; 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 (gUnknown_203ADFA == 2 || gUnknown_203ADFA == 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 < 4; i++) + { + u16 trainerId = ReadU16(((struct UnkLinkRfuStruct_02022B14 *)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 < 4; 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 UnkLinkRfuStruct_02022B14 *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 UnkLinkRfuStruct_02022B14 *structPtr2 = &Rfu.unk_10A; + 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(Rfu.unk_10A.unk_00.playerTrainerId); + u8 id = sub_80FBC70(Rfu.playerName, trainerId); + if (id != 0xFF) + { + if (!sub_80FBF98(gTasks[taskId].data[1], (struct UnkLinkRfuStruct_02022B14 *)&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 UnkLinkRfuStruct_02022B14 *structPtr, u8 a2) +{ + u8 taskId, taskId2; + + Rfu.unk_ccf = 0; + Rfu.unk_f1 = 0; + StringCopy(Rfu.playerName, name); + memcpy(&Rfu.unk_10A, structPtr, 0xD); + 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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 < 4; 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/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; } -- cgit v1.2.3 From 246e3461c78b8d6fb74cfadcfb9c72690b070069 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 12:41:43 -0500 Subject: Move GFtgtGname out of librfu.h --- src/link_rfu_2.c | 33 +++++++++++++++------------------ src/party_menu.c | 4 ++-- src/trade.c | 4 ++-- 3 files changed, 19 insertions(+), 22 deletions(-) (limited to 'src') diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 9baee37ed..ace634d17 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -58,10 +58,7 @@ struct UnkRfuStruct_2 /* 0x0fe */ u16 unk_fe; /* 0x100 */ u16 unk_100; /* 0x102 */ u8 unk_102; - /* 0x103 */ u8 filler_103[0x10A - 0x103]; - /* 0x10A */ struct UnkLinkRfuStruct_02022B14 unk_10A; - /* 0x11B */ u8 filler_; - /* 0x11C */ u8 playerName[PLAYER_NAME_LENGTH]; + /* 0x104 */ struct RfuTgtData unk_104; /* 0x124 */ struct UnkRfuStruct_2_Sub_124 unk_124; /* 0x6a0 */ struct UnkRfuStruct_2_Sub_9e8 unk_9e8; /* 0x8d4 */ struct UnkRfuStruct_2_Sub_c1c unk_c1c; @@ -112,7 +109,7 @@ static struct RfuAPIBuffer gRfuAPIBuffer; static u8 gUnknown_3001FF8[14]; static u16 gUnknown_3002008[7]; -struct UnkLinkRfuStruct_02022B14 gUnknown_3005440; +struct GFtgtGname gUnknown_3005440; struct UnkRfuStruct_2 Rfu; u8 gUnknown_3005E00[PLAYER_NAME_LENGTH]; @@ -1033,7 +1030,7 @@ static void rfu_func_080F97B8(void) } } -struct UnkLinkRfuStruct_02022B14 *sub_80F9800(void) +struct GFtgtGname *sub_80F9800(void) { return &gUnknown_3005440; } @@ -1994,7 +1991,7 @@ static void sub_80FAF1C(void) void sub_80FAF34(void) { - memset(&gUnknown_3005440, 0, 0xD); + memset(&gUnknown_3005440, 0, RFU_GAME_NAME_LENGTH); sub_80FCB54(&gUnknown_3005440, 0, 0, 0); } @@ -2107,7 +2104,7 @@ static void sub_80FB184(u8 a0, u8 unused1) { if ((gUnknown_3005E10.unk_14 >> i) & 1) { - struct UnkLinkRfuStruct_02022B14 *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; + struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; if (structPtr->unk_0a_0 == sub_80F9800()->unk_0a_0) { Rfu.unk_cd1[i] = 0; @@ -2267,7 +2264,7 @@ static u8 sub_80FB5A0(s32 a0) { if ((a0 >> i) & 1) { - struct UnkLinkRfuStruct_02022B14 *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; + struct GFtgtGname *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; if (structPtr->unk_0a_0 == 0x45) ret |= (1 << i); } @@ -2565,7 +2562,7 @@ static u8 sub_80FBC70(const u8 *a0, u16 a1) for (i = 0; i < 4; i++) { - u16 trainerId = ReadU16(((struct UnkLinkRfuStruct_02022B14 *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId); + 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) @@ -2697,7 +2694,7 @@ void sub_80FBF54(const u8 *src, u16 trainerId) data[8] = trainerId; } -static bool32 sub_80FBF98(s16 a1, struct UnkLinkRfuStruct_02022B14 *structPtr) +static bool32 sub_80FBF98(s16 a1, struct GFtgtGname *structPtr) { if (sub_80F9800()->unk_0a_0 == 0x45) { @@ -2710,7 +2707,7 @@ static bool32 sub_80FBF98(s16 a1, struct UnkLinkRfuStruct_02022B14 *structPtr) } else if (a1 == 0x44) { - struct UnkLinkRfuStruct_02022B14 *structPtr2 = &Rfu.unk_10A; + struct GFtgtGname *structPtr2 = (struct GFtgtGname *)&Rfu.unk_104.gname; if (structPtr2->species == SPECIES_EGG) { if (structPtr->species == structPtr2->species) @@ -2742,11 +2739,11 @@ static void sub_80FC028(u8 taskId) if (Rfu.unk_ccd != 0 && gUnknown_3005E10.unk_06 == 0) { - u16 trainerId = ReadU16(Rfu.unk_10A.unk_00.playerTrainerId); - u8 id = sub_80FBC70(Rfu.playerName, trainerId); + 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 UnkLinkRfuStruct_02022B14 *)&gRfuLinkStatus->partner[id].gname)) + 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)) { @@ -2763,14 +2760,14 @@ static void sub_80FC028(u8 taskId) } } -void sub_80FC114(const u8 *name, struct UnkLinkRfuStruct_02022B14 *structPtr, u8 a2) +void sub_80FC114(const u8 *name, struct GFtgtGname *structPtr, u8 a2) { u8 taskId, taskId2; Rfu.unk_ccf = 0; Rfu.unk_f1 = 0; - StringCopy(Rfu.playerName, name); - memcpy(&Rfu.unk_10A, structPtr, 0xD); + 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; diff --git a/src/party_menu.c b/src/party_menu.c index 6e0b411bf..7022852d6 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; -- cgit v1.2.3 From 0d5f88f49696d695aa934c76c500ffff4db36f4a Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 12:45:33 -0500 Subject: Move UnkRfuStruct_2 to link_rfu.h where it belongs --- src/link_rfu_2.c | 80 -------------------------------------------------------- 1 file changed, 80 deletions(-) (limited to 'src') diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index ace634d17..f63fe2a69 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -13,86 +13,6 @@ #include "task.h" #include "constants/species.h" -struct UnkRfuStruct_2_Sub_6c -{ - /* 0x00 */ u16 unk_00; - /* 0x02 */ u16 unk_02; - /* 0x04 */ const u8 *unk_04; - /* 0x08 */ u32 unk_08; - /* 0x0c */ u32 unk_0c; - /* 0x10 */ u8 unk_10; - /* 0x11 */ u8 unk_11; - /* 0x12 */ u8 unk_12; -}; - -struct UnkRfuStruct_2 -{ - /* 0x000 */ void (*RfuFunc)(void); - /* 0x004 */ u16 unk_04; - /* 0x006 */ u8 filler_06[4]; - /* 0x00a */ u16 unk_0a; - /* 0x00c */ u8 unk_0c; // parentChildMode? - /* 0x00d */ u8 playerCount; - /* 0x00e */ u8 unk_0e; - /* 0x00f */ u8 unk_0f; - /* 0x010 */ u16 unk_10; - /* 0x012 */ u16 unk_12; - /* 0x014 */ u8 unk_14[4][14]; - /* 0x04c */ u8 unk_4c[14]; - /* 0x05a */ u8 unk_5a; - /* 0x05b */ u8 unk_5b; - /* 0x05c */ u8 unk_5c[5]; - /* 0x061 */ u8 unk_61[5]; - /* 0x066 */ u8 unk_66; - /* 0x067 */ u8 unk_67; - /* 0x068 */ u8 filler_68[4]; - /* 0x06c */ struct UnkRfuStruct_2_Sub_6c unk_6c; - /* 0x080 */ struct UnkRfuStruct_2_Sub_6c unk_80[5]; - /* 0x0e4 */ u8 unk_e4[5]; - /* 0x0e9 */ u8 unk_e9[5]; - /* 0x0ee */ vu8 unk_ee; - /* 0x0ef */ u8 unk_ef; - /* 0x0f0 */ u8 unk_f0; - /* 0x0f1 */ u8 unk_f1; - /* 0x0f2 */ u16 unk_f2[6]; - /* 0x0fe */ u16 unk_fe; - /* 0x100 */ u16 unk_100; - /* 0x102 */ u8 unk_102; - /* 0x104 */ struct RfuTgtData unk_104; - /* 0x124 */ struct UnkRfuStruct_2_Sub_124 unk_124; - /* 0x6a0 */ struct UnkRfuStruct_2_Sub_9e8 unk_9e8; - /* 0x8d4 */ struct UnkRfuStruct_2_Sub_c1c unk_c1c; - /* 0x8f4 */ vu8 unk_c3c; - /* 0x8f5 */ u8 unk_c3d; - /* 0x8f6 */ vu8 unk_c3e; - /* 0x8f7 */ u8 unk_c3f[70]; - /* 0x93d */ u8 unk_c85; - /* 0x93e */ u8 unk_c86; - /* 0x93f */ u8 unk_c87[5][7][2]; - /* 0x985 */ u8 unk_ccd; - /* 0x986 */ u8 unk_cce; // childId - /* 0x987 */ u8 unk_ccf; - /* 0x988 */ vu8 unk_cd0; - /* 0x989 */ u8 unk_cd1[4]; - /* 0x98d */ u8 unk_cd5[4]; - /* 0x991 */ u8 unk_cd9; - /* 0x992 */ u8 unk_cda; - /* 0x993 */ vu8 unk_cdb; - /* 0x994 */ vu8 unk_cdc; - /* 0x995 */ u8 unk_cdd; - /* 0x996 */ u8 unk_cde[4]; - /* 0x99a */ u8 unk_ce2; - /* 0x99b */ u8 unk_ce3; - /* 0x99c */ u8 unk_ce4; - /* 0x99d */ u8 unk_ce5; - /* 0x99e */ u8 unk_ce6; - /* 0x99f */ u8 unk_ce7; - /* 0x9a0 */ u8 unk_ce8; - /* 0x9a1 */ u8 unk_ce9; - /* 0x9a2 */ u8 unk_cea[4]; - /* 0x9a6 */ u8 unk_cee[4]; -}; // size: 0x9AC - struct UnkRfuStruct_8010A14{ char unk_00[15]; // PokemonSioInfo u8 unk_0f; -- cgit v1.2.3 From 5ef7bf7bf4208f806214c781a2367d4129732461 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 12:50:49 -0500 Subject: data/link_rfu.s --> data/easy_chat_2.s --- src/link.c | 2 +- src/link_rfu.c | 2 +- src/link_rfu_2.c | 91 +++++---- src/link_rfu_4.c | 596 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 643 insertions(+), 48 deletions(-) create mode 100644 src/link_rfu_4.c (limited to 'src') diff --git a/src/link.c b/src/link.c index bdaa48cdf..7be93026b 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 index 195394cfe..0d6e14551 100644 --- a/src/link_rfu.c +++ b/src/link_rfu.c @@ -417,7 +417,7 @@ static bool8 sub_80FD850(u16 reqCommandId) return retVal; } -void rfu_syncVBlank_(void) +void LinkRfu_syncVBlank_(void) { if (rfu_syncVBlank()) { diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index f63fe2a69..a06e3bc9c 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -24,7 +24,6 @@ struct UnkRfuStruct_8010A14{ static EWRAM_DATA struct UnkLinkRfuStruct_02022B2C gUnknown_203ABF0 = {}; static EWRAM_DATA struct UnkLinkRfuStruct_02022B44 gUnknown_203AC08 = {}; -static u8 gUnknown_3001188; static struct RfuAPIBuffer gRfuAPIBuffer; static u8 gUnknown_3001FF8[14]; static u16 gUnknown_3002008[7]; @@ -276,7 +275,7 @@ static void sub_80F887C(s32 r2, s32 r5) s32 r6 = 0; if (r5 == -1) { - for (i = 0; i < 4; r2 >>= 1, i++) + for (i = 0; i < RFU_CHILD_MAX; r2 >>= 1, i++) { if (r2 & 1) { @@ -287,7 +286,7 @@ static void sub_80F887C(s32 r2, s32 r5) } else { - for (i = 0; i < 4; r1 >>= 1, i++) + for (i = 0; i < RFU_CHILD_MAX; r1 >>= 1, i++) { if (!(r1 & 1)) { @@ -296,13 +295,13 @@ static void sub_80F887C(s32 r2, s32 r5) } for (r4 = 4; r4 != 0; r4--) { - for (i = 0; i < 4 && Rfu.unk_cde[i] != r4; i++); + for (i = 0; i < RFU_CHILD_MAX && Rfu.unk_cde[i] != r4; i++); if (i == 4) { r6 = r4; } } - for (r5 &= ~r2, i = 0; i < 4; r5 >>= 1, i++) + for (r5 &= ~r2, i = 0; i < RFU_CHILD_MAX; r5 >>= 1, i++) { if (r5 & 1) { @@ -351,8 +350,8 @@ static void sub_80F893C(u8 taskId) { u8 r5 = 1 << Rfu.unk_c3e; rfu_clearSlot(12, Rfu.unk_c3e); - rfu_setRecvBuffer(16, Rfu.unk_c3e, Rfu.unk_c3f, 70); - rfu_UNI_setSendData(r5, Rfu.unk_4c, 14); + 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) @@ -370,11 +369,11 @@ static void sub_80F8AA4(void) { u8 i; u8 r5 = gUnknown_3005E10.unk_00; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (r5 & 1) { - rfu_setRecvBuffer(16, i, Rfu.unk_14[i], 14); + rfu_setRecvBuffer(16, i, Rfu.unk_14[i], sizeof(Rfu.unk_14[i])); rfu_clearSlot(3, i); } r5 >>= 1; @@ -384,7 +383,7 @@ static void sub_80F8AA4(void) static void sub_80F8AEC(void) { u8 r5 = gUnknown_3005E10.unk_00; - rfu_UNI_setSendData(r5, Rfu.unk_c87, 70); + 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); @@ -416,7 +415,7 @@ static void sub_80F8B34(u8 taskId) case 18: break; case 13: - if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, 14) == 0) + if (rfu_UNI_setSendData(1 << Rfu.unk_c3e, Rfu.unk_4c, sizeof(Rfu.unk_4c)) == 0) { Rfu.unk_0c = 0; DestroyTask(taskId); @@ -521,7 +520,7 @@ void sub_80F8DC0(void) sub_80F85F8(); } } - for (i = 0; i < 3; i++) + for (i = 0; i < NELEMS(gUnknown_843ED88); i++) { if (FuncIsActiveTask(gUnknown_843ED88[i]) == TRUE) { @@ -597,7 +596,7 @@ static void sub_80F8FAC(u8 a0) { u8 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (a0 & 1) { @@ -751,7 +750,7 @@ static bool32 sub_80F9204(void) Rfu.unk_cdc = 0; gUnknown_203AC08.unk_06++; flags = gUnknown_3005E10.unk_00; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (flags & 1) { @@ -787,18 +786,18 @@ static bool32 sub_80F9204(void) { gUnknown_203AC08.unk_0e = 0; rfu_clearSlot(3, Rfu.unk_cda); - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.unk_ce5 >> i) & 1) { - rfu_setRecvBuffer(0x10, i, Rfu.unk_14[i], 14); + 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, 70); + 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); } @@ -930,7 +929,7 @@ static u8 sub_80F9770(const u8 *a0) if (Rfu.unk_0c == 1) return FALSE; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { Rfu.unk_cde[i] = a0[i]; } @@ -939,7 +938,7 @@ static u8 sub_80F9770(const u8 *a0) static void rfu_func_080F97B8(void) { - // static u8 gUnknown_3001188; + static u8 gUnknown_3001188; if (gReceivedRemoteLinkPlayers && gHeldKeyCodeToSend != LINK_KEY_CODE_NULL && gLinkTransferringData != TRUE) @@ -1149,7 +1148,7 @@ static void sub_80F9D04(u16 command) Rfu.playerCount = gUnknown_843EC41[tmp] + 1; gSendCmd[1] = Rfu.playerCount; buff = (u8 *)(gSendCmd + 2); - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) buff[i] = Rfu.unk_cde[i]; break; case 0x6600: @@ -1450,7 +1449,7 @@ bool32 sub_80FA44C(u32 a0) u8 sub_80FA484(bool32 a0) { - if (a0 == FALSE) + if (!a0) return sub_80FEA34(0, 0); sub_80FEA34(1, 0x258); return 0; @@ -1462,7 +1461,7 @@ void sub_80FA4A8(void) sub_80FD760(FALSE); } -u8 rfu_get_multiplayer_id(void) +u8 LinkRfu_GetMultiplayerId(void) { if (Rfu.unk_0c == 1) return 0; @@ -1476,12 +1475,12 @@ u8 GetRfuPlayerCount(void) bool8 IsLinkRfuTaskFinished(void) { - return Rfu.RfuFunc ? FALSE : TRUE; + return Rfu.RfuFunc != NULL ? FALSE : TRUE; } static void CallRfuFunc(void) { - if (Rfu.RfuFunc) + if (Rfu.RfuFunc != NULL) Rfu.RfuFunc(); } @@ -1518,7 +1517,7 @@ bool32 sub_80FA5D4(void) { u8 flags = 0; s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.unk_cd5[i] == 11) { @@ -1531,7 +1530,7 @@ bool32 sub_80FA5D4(void) rfu_REQ_disconnect(flags); rfu_waitREQComplete(); } - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.unk_cd5[i] == 10 || Rfu.unk_cd5[i] == 11) return TRUE; @@ -1579,7 +1578,7 @@ static void sub_80FA738(void) s32 i; sub_80FA528(); - for (i = 0; i < 4; i++) + 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) { @@ -1683,7 +1682,7 @@ static void sub_80FA834(u8 taskId) sub_80FEA34(1, 0x258); if (Rfu.unk_ce6) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.unk_ce6 >> i) & 1) { @@ -1700,7 +1699,7 @@ static void sub_80FA9D0(u16 a0) { s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((a0 >> i) & 1) Rfu.unk_cde[i] = 0; @@ -1711,7 +1710,7 @@ static void sub_80FA9FC(const struct UnkRfuStruct_8010A14 *a0) { s32 i; Rfu.playerCount = a0->unk_0f; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) Rfu.unk_cde[i] = a0->unk_10[i]; for (i = 0; i < MAX_RFU_PLAYERS; i++) { @@ -1769,7 +1768,7 @@ static void sub_80FAA94(u8 taskId) r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer; memcpy(r5->unk_00, "PokemonSioInfo", sizeof("PokemonSioInfo")); r5->unk_0f = Rfu.playerCount; - for (i = 0; i < 4; i++) + 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]++; @@ -1777,7 +1776,7 @@ static void sub_80FAA94(u8 taskId) case 4: r5 = (struct UnkRfuStruct_8010A14 *)gBlockSendBuffer; r5->unk_0f = Rfu.playerCount; - for (i = 0; i < 4; i++) + 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)) @@ -1791,7 +1790,7 @@ static void sub_80FAA94(u8 taskId) Rfu.unk_ce8 = 0; if (Rfu.unk_ce6) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((Rfu.unk_ce6 >> i) & 1) { @@ -1958,7 +1957,7 @@ void sub_80FB030(u32 a0) r5 = 0; r7 = 0; r8 = Rfu.unk_ce2 ^ Rfu.unk_ce3; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((r8 >> i) & 1) { @@ -2020,7 +2019,7 @@ static void sub_80FB184(u8 a0, u8 unused1) break; case 0x11: sub_80FB564(gUnknown_3005E10.unk_14); - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gUnknown_3005E10.unk_14 >> i) & 1) { @@ -2165,7 +2164,7 @@ static void sub_80FB564(s32 a0) { s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((a0 >> i) & 1) { @@ -2180,7 +2179,7 @@ static u8 sub_80FB5A0(s32 a0) u8 ret = 0; u8 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((a0 >> i) & 1) { @@ -2370,7 +2369,7 @@ bool8 Rfu_IsMaster(void) void RFUVSync(void) { - rfu_syncVBlank_(); + LinkRfu_syncVBlank_(); } void sub_80FBA44(void) @@ -2400,7 +2399,7 @@ static void sub_80FBA78(void) sub_800B1F4(); OpenLink(); SeedRng(gMain.vblankCounter2); - for (i = 0; i < 4; i++) + 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); @@ -2480,7 +2479,7 @@ static u8 sub_80FBC70(const u8 *a0, u16 a1) u8 i; u8 ret = 0xFF; - for (i = 0; i < 4; i++) + 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) @@ -2520,7 +2519,7 @@ void sub_80FBD6C(u32 a0) s32 i; u8 var = 0; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if (Rfu.unk_cde[i] == a0 && (Rfu.unk_ce2 >> i) & 1) var |= 1 << i; @@ -2716,7 +2715,7 @@ bool32 sub_80FC1CC(void) { s32 i; - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gUnknown_3005E10.unk_00 >> i) & 1 && Rfu.unk_cd1[i] == 0) return FALSE; @@ -2755,7 +2754,7 @@ static void sub_80FC228(void) nullsub_88(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1); if (Rfu.unk_0c == 1) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { if ((gRfuLinkStatus->getNameFlag >> i) & 1) { @@ -2764,7 +2763,7 @@ static void sub_80FC228(void) nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { for (j = 0; j < 14; j++) { @@ -2775,7 +2774,7 @@ static void sub_80FC228(void) } else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0) { - for (i = 0; i < 4; i++) + for (i = 0; i < RFU_CHILD_MAX; i++) { nullsub_88(0, 1, i + 3, 4); nullsub_87(gUnknown_843EE47, 6, i + 3); @@ -2796,7 +2795,7 @@ static void sub_80FC228(void) nullsub_87(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); } } - for (; i < 4; i++) + for (; i < RFU_CHILD_MAX; i++) { nullsub_88(0, 1, i + 3, 4); nullsub_87(gUnknown_843EE47, 6, i + 3); diff --git a/src/link_rfu_4.c b/src/link_rfu_4.c new file mode 100644 index 000000000..44ea69d35 --- /dev/null +++ b/src/link_rfu_4.c @@ -0,0 +1,596 @@ +#include "global.h" +#include "link_rfu.h" +#include "random.h" +#include "text.h" + +const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal"); + +const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz"); + +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 +}; + +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 +}; + +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, + }; + +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) +}; + +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) +}; + +const union AnimCmd sWirelessStatusIndicatorAnim2[] = { + // 1 bar + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_JUMP(0) +}; + +const union AnimCmd sWirelessStatusIndicatorAnim3[] = { + // searching + ANIMCMD_FRAME( 4, 10), + ANIMCMD_FRAME(20, 10), + ANIMCMD_JUMP(0) +}; + +const union AnimCmd sWirelessStatusIndicatorAnim4[] = { + // error + ANIMCMD_FRAME(24, 10), + ANIMCMD_FRAME( 4, 10), + ANIMCMD_JUMP(0) +}; + +const union AnimCmd *const sWirelessStatusIndicatorAnims[] = { + sWirelessStatusIndicatorAnim0, + sWirelessStatusIndicatorAnim1, + sWirelessStatusIndicatorAnim2, + sWirelessStatusIndicatorAnim3, + sWirelessStatusIndicatorAnim4 +}; + +const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = { + gWirelessLinkIconPic, 0x0380, 0xD431 +}; + +const struct SpritePalette sWirelessStatusIndicatorSpritePalette = { + gWirelessLinkIconPalette, 0xD432 +}; + +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; +} + +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; +} + +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; + } +} + +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; +} + +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; + } +} + +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; +} + +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 +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 +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 -- cgit v1.2.3 From de939451d7ee99749a1a26870ce27d88cd47a41b Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 17:07:43 -0500 Subject: link_rfu_4 mostly --- src/link_rfu_4.c | 334 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) (limited to 'src') diff --git a/src/link_rfu_4.c b/src/link_rfu_4.c index 44ea69d35..80973e30d 100644 --- a/src/link_rfu_4.c +++ b/src/link_rfu_4.c @@ -1,7 +1,15 @@ #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" + +EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0; const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal"); @@ -594,3 +602,329 @@ u8 sub_80FCADC(u8 maxFlags) "\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; +} + +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; +} + +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(); + } + } +} + +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; +} + +void ZeroName(u8 *name) +{ + s32 i; + + for (i = 0; i < PLAYER_NAME_LENGTH; i++) + { + *name++ = 0; + } +} + +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); + } +} -- cgit v1.2.3 From f3e8f6c65f431be5a7e8c03091027e6ccbc98ddf Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 18:42:05 -0500 Subject: Finish link_rfu_4 --- src/link_rfu_4.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) (limited to 'src') diff --git a/src/link_rfu_4.c b/src/link_rfu_4.c index 80973e30d..368431281 100644 --- a/src/link_rfu_4.c +++ b/src/link_rfu_4.c @@ -928,3 +928,21 @@ void RecordMixTrainerNames(void) 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; +} -- cgit v1.2.3 From 87302a21033e6f41d0007d962b37fb16cca995df Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 20:53:19 -0500 Subject: link_rfu_4 static --- src/link_rfu_4.c | 56 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 28 insertions(+), 28 deletions(-) (limited to 'src') diff --git a/src/link_rfu_4.c b/src/link_rfu_4.c index 368431281..01f19d817 100644 --- a/src/link_rfu_4.c +++ b/src/link_rfu_4.c @@ -9,13 +9,13 @@ #include "text.h" #include "constants/flags.h" -EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0; +static EWRAM_DATA u8 gWirelessStatusIndicatorSpriteId = 0; -const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal"); +static const u16 gWirelessLinkIconPalette[] = INCBIN_U16("graphics/interface/wireless_link_icon.gbapal"); -const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz"); +static const u32 gWirelessLinkIconPic[] = INCBIN_U32("graphics/interface/wireless_link_icon.4bpp.lz"); -const u8 sWireless_ASCIItoRSETable[] = { +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, @@ -50,7 +50,7 @@ const u8 sWireless_ASCIItoRSETable[] = { 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94 }; -const u8 sWireless_RSEtoASCIITable[] = { +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, @@ -85,7 +85,7 @@ const u8 sWireless_RSEtoASCIITable[] = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00 }; -const struct OamData sWirelessStatusIndicatorOamData = +static const struct OamData sWirelessStatusIndicatorOamData = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -99,7 +99,7 @@ const struct OamData sWirelessStatusIndicatorOamData = .paletteNum = 0, }; -const union AnimCmd sWirelessStatusIndicatorAnim0[] = { +static const union AnimCmd sWirelessStatusIndicatorAnim0[] = { // 3 bars ANIMCMD_FRAME( 4, 5), ANIMCMD_FRAME( 8, 5), @@ -110,7 +110,7 @@ const union AnimCmd sWirelessStatusIndicatorAnim0[] = { ANIMCMD_JUMP(0) }; -const union AnimCmd sWirelessStatusIndicatorAnim1[] = { +static const union AnimCmd sWirelessStatusIndicatorAnim1[] = { // 2 bars ANIMCMD_FRAME( 4, 5), ANIMCMD_FRAME( 8, 5), @@ -119,28 +119,28 @@ const union AnimCmd sWirelessStatusIndicatorAnim1[] = { ANIMCMD_JUMP(0) }; -const union AnimCmd sWirelessStatusIndicatorAnim2[] = { +static const union AnimCmd sWirelessStatusIndicatorAnim2[] = { // 1 bar ANIMCMD_FRAME(4, 5), ANIMCMD_FRAME(8, 5), ANIMCMD_JUMP(0) }; -const union AnimCmd sWirelessStatusIndicatorAnim3[] = { +static const union AnimCmd sWirelessStatusIndicatorAnim3[] = { // searching ANIMCMD_FRAME( 4, 10), ANIMCMD_FRAME(20, 10), ANIMCMD_JUMP(0) }; -const union AnimCmd sWirelessStatusIndicatorAnim4[] = { +static const union AnimCmd sWirelessStatusIndicatorAnim4[] = { // error ANIMCMD_FRAME(24, 10), ANIMCMD_FRAME( 4, 10), ANIMCMD_JUMP(0) }; -const union AnimCmd *const sWirelessStatusIndicatorAnims[] = { +static const union AnimCmd *const sWirelessStatusIndicatorAnims[] = { sWirelessStatusIndicatorAnim0, sWirelessStatusIndicatorAnim1, sWirelessStatusIndicatorAnim2, @@ -148,15 +148,15 @@ const union AnimCmd *const sWirelessStatusIndicatorAnims[] = { sWirelessStatusIndicatorAnim4 }; -const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = { +static const struct CompressedSpriteSheet sWirelessStatusIndicatorSpriteSheet = { gWirelessLinkIconPic, 0x0380, 0xD431 }; -const struct SpritePalette sWirelessStatusIndicatorSpritePalette = { +static const struct SpritePalette sWirelessStatusIndicatorSpritePalette = { gWirelessLinkIconPalette, 0xD432 }; -const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = { +static const struct SpriteTemplate sWirelessStatusIndicatorSpriteTemplate = { 0xD431, 0xD432, &sWirelessStatusIndicatorOamData, @@ -202,7 +202,7 @@ void sub_80FC4D4(struct UnkRfuStruct_2_Sub_9e8 *ptr) ptr->unk_233 = 0; } -void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr) +static void sub_80FC530(struct UnkRfuStruct_Sub_Unused *ptr) { s32 i; s32 j; @@ -395,7 +395,7 @@ bool8 sub_80FC888(struct UnkRfuStruct_2_Sub_c1c *q1, u8 *q2) return TRUE; } -void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +static void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) { s32 i; @@ -415,7 +415,7 @@ void sub_80FC8D8(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) } } -bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) +static bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) { s32 i; @@ -433,7 +433,7 @@ bool8 sub_80FC944(struct UnkRfuStruct_Sub_Unused *q1, u8 *q2) return TRUE; } -void sub_80FC9B8(u8 *q1, u8 mode) +static void sub_80FC9B8(u8 *q1, u8 mode) { s32 i; u8 rval; @@ -479,7 +479,7 @@ void sub_80FC9B8(u8 *q1, u8 mode) } } -void PkmnStrToASCII(u8 *q1, const u8 *q2) +static void PkmnStrToASCII(u8 *q1, const u8 *q2) { s32 i; @@ -490,7 +490,7 @@ void PkmnStrToASCII(u8 *q1, const u8 *q2) q1[i] = 0; } -void ASCIIToPkmnStr(u8 *q1, const u8 *q2) +static void ASCIIToPkmnStr(u8 *q1, const u8 *q2) { s32 i; @@ -502,7 +502,7 @@ void ASCIIToPkmnStr(u8 *q1, const u8 *q2) } #ifdef NONMATCHING -u8 sub_80FCADC(u8 maxFlags) +static u8 sub_80FCADC(u8 maxFlags) { u8 flagCount = 0; u8 flags = gRfuLinkStatus->connSlotFlag; @@ -533,7 +533,7 @@ u8 sub_80FCADC(u8 maxFlags) } #else NAKED -u8 sub_80FCADC(u8 maxFlags) +static u8 sub_80FCADC(u8 maxFlags) { asm_unified("\tpush {r4-r7,lr}\n" "\tlsls r0, 24\n" @@ -734,7 +734,7 @@ void LoadWirelessStatusIndicatorSpriteGfx(void) gWirelessStatusIndicatorSpriteId = 0xFF; } -u8 sub_80FCEE4(void) +static u8 sub_80FCEE4(void) { u8 i; u8 flags = gRfuLinkStatus->connSlotFlag; @@ -749,7 +749,7 @@ u8 sub_80FCEE4(void) return 0; } -void sub_80FCF1C(struct Sprite *sprite, s32 signalStrengthAnimNum) +static void sub_80FCF1C(struct Sprite *sprite, s32 signalStrengthAnimNum) { if (sprite->data[2] != signalStrengthAnimNum) { @@ -831,7 +831,7 @@ void sub_80FCF34(void) } } -void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 *name) +static void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 *name) { int i; dest->trainerId = trainerId; @@ -844,7 +844,7 @@ void CopyTrainerRecord(struct TrainerNameRecord *dest, u32 trainerId, const u8 * dest->trainerName[i] = EOS; } -void ZeroName(u8 *name) +static void ZeroName(u8 *name) { s32 i; @@ -854,7 +854,7 @@ void ZeroName(u8 *name) } } -bool32 NameIsEmpty(const u8 *name) +static bool32 NameIsEmpty(const u8 *name) { s32 i; -- cgit v1.2.3 From 69994e89ca0baf69cd43d5df10560300150654f7 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 14 Jan 2020 20:57:31 -0500 Subject: Rename files: link_rfu_3 --> union_room, link_rfu_4 --> link_rfu_3 --- src/link_rfu_3.c | 948 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/link_rfu_4.c | 948 ------------------------------------------------------- 2 files changed, 948 insertions(+), 948 deletions(-) create mode 100644 src/link_rfu_3.c delete mode 100644 src/link_rfu_4.c (limited to 'src') 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/link_rfu_4.c b/src/link_rfu_4.c deleted file mode 100644 index 01f19d817..000000000 --- a/src/link_rfu_4.c +++ /dev/null @@ -1,948 +0,0 @@ -#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; -} -- cgit v1.2.3