From b3c47d0059c20fbdaf2f16c26971259e006e70e4 Mon Sep 17 00:00:00 2001 From: GriffinR Date: Mon, 7 Nov 2022 10:59:49 -0500 Subject: [PATCH] Finish syncing link_rfu_2 --- common_syms/link_rfu_2.txt | 2 +- include/gba/types.h | 3 + include/link.h | 3 +- include/link_rfu.h | 246 ++- include/mystery_gift_menu.h | 2 +- src/battle_controllers.c | 2 +- src/berry_crush.c | 6 +- src/link.c | 28 +- src/link_rfu_2.c | 2148 ++++++++++---------- src/link_rfu_3.c | 84 +- src/main.c | 2 +- src/mystery_gift_menu.c | 6 +- src/overworld.c | 2 +- src/party_menu.c | 4 +- src/pokemon_jump.c | 2 +- src/rfu_union_tool.c | 8 +- src/trade.c | 8 +- src/union_room.c | 204 +- src/union_room_chat.c | 30 +- src/wireless_communication_status_screen.c | 2 +- 20 files changed, 1437 insertions(+), 1355 deletions(-) diff --git a/common_syms/link_rfu_2.txt b/common_syms/link_rfu_2.txt index abd9a5f93..3a84c23bf 100644 --- a/common_syms/link_rfu_2.txt +++ b/common_syms/link_rfu_2.txt @@ -1,3 +1,3 @@ gHostRfuGameData -Rfu +gRfu gHostRfuUsername diff --git a/include/gba/types.h b/include/gba/types.h index 7163f925f..35d02e263 100644 --- a/include/gba/types.h +++ b/include/gba/types.h @@ -27,6 +27,9 @@ typedef double f64; typedef u8 bool8; typedef u16 bool16; typedef u32 bool32; +typedef vu8 vbool8; +typedef vu16 vbool16; +typedef vu32 vbool32; struct BgCnt { diff --git a/include/link.h b/include/link.h index 74a94920c..1ac0913a2 100644 --- a/include/link.h +++ b/include/link.h @@ -250,7 +250,7 @@ void SetSuppressLinkErrorMessage(bool8); bool8 HasLinkErrorOccurred(void); void ResetSerial(void); u32 LinkMain1(u8 *, u16 *, u16[MAX_RFU_PLAYERS][CMD_LENGTH]); -void RFUVSync(void); +void RfuVSync(void); void Timer3Intr(void); void SerialCB(void); u8 GetLinkPlayerCount(void); @@ -258,7 +258,6 @@ bool32 InUnionRoom(void); void SetLinkStandbyCallback(void); void SetWirelessCommType1(void); -void LinkRfu_DestroyIdleTask(void); void SetCloseLinkCallback(void); void OpenLink(void); bool8 IsLinkMaster(void); diff --git a/include/link_rfu.h b/include/link_rfu.h index e22414786..f203d30a3 100644 --- a/include/link_rfu.h +++ b/include/link_rfu.h @@ -6,33 +6,29 @@ #include "link.h" #include "AgbRfu_LinkManager.h" -#define RFUCMD_MASK 0xFF00 +#define RFUCMD_MASK 0xFF00 -#define RFUCMD_SEND_PACKET 0x2F00 -#define RFUCMD_READY_CLOSE_LINK 0x5f00 -#define RFUCMD_READY_EXIT_STANDBY 0x6600 -#define RFUCMD_PLAYERS_LIST 0x7700 -#define RFUCMD_PLAYERS_LIST_2 0x7800 -#define RFUCMD_SEND_BLOCK_INIT 0x8800 -#define RFUCMD_SEND_BLOCK_STEP 0x8900 -#define RFUCMD_SEND_BLOCK_REQ 0xa100 -#define RFUCMD_SEND_HELD_KEYS 0xbe00 -#define RFUCMD_PARENT_DISCONNECT 0xed00 -#define RFUCMD_CHILD_DISCONNECT 0xee00 +#define RFUCMD_SEND_PACKET 0x2F00 +#define RFUCMD_BLENDER_SEND_KEYS 0x4400 +#define RFUCMD_READY_CLOSE_LINK 0x5F00 +#define RFUCMD_READY_EXIT_STANDBY 0x6600 +#define RFUCMD_SEND_PLAYER_IDS 0x7700 +#define RFUCMD_SEND_PLAYER_IDS_NEW 0x7800 +#define RFUCMD_SEND_BLOCK_INIT 0x8800 +#define RFUCMD_SEND_BLOCK 0x8900 +#define RFUCMD_SEND_BLOCK_REQ 0xA100 +#define RFUCMD_SEND_HELD_KEYS 0xBE00 +#define RFUCMD_DISCONNECT 0xED00 +#define RFUCMD_DISCONNECT_PARENT 0xEE00 -#define RFU_PACKET_SIZE 6 - -#define RFU_SERIAL_7F7D 0x7F7D +#define RFU_SERIAL_GAME 0x0002 // Serial number for Pokémon game (FRLG or Emerald) +#define RFU_SERIAL_WONDER_DISTRIBUTOR 0x7F7D // Serial number for distributing Wonder Cards / News +#define RFU_SERIAL_END 0xFFFF +#define COMM_SLOT_LENGTH 14 #define RECV_QUEUE_NUM_SLOTS 20 -#define RECV_QUEUE_SLOT_LENGTH (14 * MAX_RFU_PLAYERS) - #define SEND_QUEUE_NUM_SLOTS 40 -#define SEND_QUEUE_SLOT_LENGTH 14 - #define BACKUP_QUEUE_NUM_SLOTS 2 -#define BACKUP_QUEUE_SLOT_LENGTH 14 - #define UNUSED_QUEUE_NUM_SLOTS 2 #define UNUSED_QUEUE_SLOT_LENGTH 256 @@ -48,13 +44,40 @@ #define RFU_STATUS_WAIT_ACK_JOIN_GROUP 7 #define RFU_STATUS_LEAVE_GROUP_NOTICE 8 #define RFU_STATUS_LEAVE_GROUP 9 -#define RFU_STATUS_10 10 -#define RFU_STATUS_11 11 +#define RFU_STATUS_CHILD_LEAVE_READY 10 +#define RFU_STATUS_CHILD_LEAVE 11 #define RFU_STATUS_ACK_JOIN_GROUP 12 -#define RFU_RECV_IDLE 0 -#define RFU_RECV_RECEIVING 1 -#define RFU_RECV_FINISHED 2 +// Values for disconnectMode +enum { + RFU_DISCONNECT_NONE, + RFU_DISCONNECT_ERROR, + RFU_DISCONNECT_NORMAL, +}; + +// Values for errorState +enum { + RFU_ERROR_STATE_NONE, + RFU_ERROR_STATE_OCCURRED, + RFU_ERROR_STATE_PROCESSED, + RFU_ERROR_STATE_DISCONNECTING, + RFU_ERROR_STATE_IGNORE, +}; + +// These error flags are set in errorInfo, and given as +// the uppermost 16 bits of 'status' for sLinkErrorBuffer. +// The first 8 bits are reserved for the link manager msg +// when the error occurred, and the last 8 bits are this +// sequence of presumably meaningful error flags, but +// ultimately sLinkErrorBuffer's status is never read. +#define F_RFU_ERROR_1 (1 << 8) +#define F_RFU_ERROR_2 (1 << 9) // Never set +#define F_RFU_ERROR_3 (1 << 10) // Never set +#define F_RFU_ERROR_4 (1 << 11) // Never set +#define F_RFU_ERROR_5 (1 << 12) +#define F_RFU_ERROR_6 (1 << 13) +#define F_RFU_ERROR_7 (1 << 14) +#define F_RFU_ERROR_8 (1 << 15) // RfuTgtData.gname is read as these structs. struct RfuGameCompatibilityData @@ -62,36 +85,47 @@ struct RfuGameCompatibilityData u16 language:4; u16 hasNews:1; u16 hasCard:1; - u16 unknown:1; + u16 unknown:1; // Never read u16 isChampion:1; u16 hasNationalDex:1; u16 gameClear:1; u16 version:4; - u16 unk_01_6:2; + u16 unused:2; u8 playerTrainerId[2]; }; +// This struct is sent via the Wireless Adapter as the game name or "gname" data. +// Gname is only applicable during Wireless Single Game Pak Multiplay, when the +// adapter needs this data for connection. Per the RFU manual, during "normal" +// wireless play (the kind the Pokémon games use) the gname data can be used for +// anything the developers want. This struct is what GF decided to use it for. +// It can be up to 13 bytes in size (RFU_GAME_NAME_LENGTH). +// The player's name is sent separately as the username ("uname"), and does not +// use a struct (gHostRfuUsername). struct __attribute__((packed, aligned(2))) RfuGameData { - struct RfuGameCompatibilityData unk_00; - u8 child_sprite_gender[RFU_CHILD_MAX]; // u8 sprite_idx:3; - // u8 gender:1; - // u8 unk_4:3 - // u8 active:1 - u16 species:10; - u16 type:6; + struct RfuGameCompatibilityData compatibility; + u8 partnerInfo[RFU_CHILD_MAX]; + u16 tradeSpecies:10; + u16 tradeType:6; u8 activity:7; - u8 started:1; + u8 startedActivity:1; u8 playerGender:1; - u8 level:7; + u8 tradeLevel:7; u8 padding; -}; // size: RFU_GNAME_SIZE - -struct Padded_U8 -{ - u8 value; }; +// Constants for getting/setting information in 'partnerInfo' of RfuGameData. +// This data is used to determine what the link partners look like from +// the host's perspective. +// Bits 0-2 are a shortened trainerId +// Bit 3 is the player's gender +// Bits 4-6 are unknown/unused +// Bit 7 is an 'active' flag +#define PINFO_TID_MASK 0x7 +#define PINFO_GENDER_SHIFT 3 +#define PINFO_ACTIVE_FLAG (1 << 7) + struct RfuBlockSend { /* 0x00 */ u16 next; @@ -106,7 +140,7 @@ struct RfuBlockSend struct RfuRecvQueue { - /* 0x000 */ u8 slots[RECV_QUEUE_NUM_SLOTS][RECV_QUEUE_SLOT_LENGTH]; + /* 0x000 */ u8 slots[RECV_QUEUE_NUM_SLOTS][COMM_SLOT_LENGTH * MAX_RFU_PLAYERS]; /* 0x578 */ vu8 recv_slot; /* 0x579 */ vu8 send_slot; /* 0x57a */ vu8 count; @@ -115,7 +149,7 @@ struct RfuRecvQueue struct RfuSendQueue { - /* 0x000 */ u8 slots[SEND_QUEUE_NUM_SLOTS][SEND_QUEUE_SLOT_LENGTH]; + /* 0x000 */ u8 slots[SEND_QUEUE_NUM_SLOTS][COMM_SLOT_LENGTH]; /* 0x230 */ vu8 recv_slot; /* 0x231 */ vu8 send_slot; /* 0x232 */ vu8 count; @@ -124,7 +158,7 @@ struct RfuSendQueue struct RfuBackupQueue { - /* 0x00 */ u8 slots[BACKUP_QUEUE_NUM_SLOTS][BACKUP_QUEUE_SLOT_LENGTH]; + /* 0x00 */ u8 slots[BACKUP_QUEUE_NUM_SLOTS][COMM_SLOT_LENGTH]; /* 0x1c */ vu8 recv_slot; /* 0x1d */ vu8 send_slot; /* 0x1e */ vu8 count; @@ -141,24 +175,24 @@ struct RfuUnusedQueue struct RfuManager { - /* 0x000 */ void (*RfuFunc)(void); + /* 0x000 */ void (*callback)(void); /* 0x004 */ u16 state; - /* 0x006 */ u8 filler_06[4]; - /* 0x00a */ u16 linkman_msg; - /* 0x00c */ u8 parent_child; + /* 0x006 */ u8 unused1[4]; + /* 0x00a */ u16 errorInfo; + /* 0x00c */ u8 parentChild; /* 0x00d */ u8 playerCount; - /* 0x00e */ u8 unk_0e; - /* 0x00f */ u8 unk_0f; - /* 0x010 */ u16 linkman_param[2]; - /* 0x014 */ u8 main_UNI_recvBuffer[RFU_CHILD_MAX][14]; - /* 0x04c */ u8 lastCmdBeforeCommInterrupt[14]; - /* 0x05a */ u8 cmdA100_blockRequestType; + /* 0x00e */ bool8 runParentMain2; + /* 0x00f */ u8 unused2; + /* 0x010 */ u16 errorParams[2]; + /* 0x014 */ u8 childRecvBuffer[RFU_CHILD_MAX][COMM_SLOT_LENGTH]; + /* 0x04c */ u8 childSendBuffer[COMM_SLOT_LENGTH]; + /* 0x05a */ u8 blockRequestType; /* 0x05b */ u8 sendBlockInitDelay; /* 0x05c */ bool8 blockReceived[MAX_RFU_PLAYERS]; /* 0x061 */ u8 numBlocksReceived[MAX_RFU_PLAYERS]; /* 0x066 */ u8 idleTaskId; /* 0x067 */ u8 searchTaskId; - /* 0x068 */ u8 filler_68[4]; + /* 0x068 */ u8 unused3[4]; /* 0x06c */ struct RfuBlockSend sendBlock; /* 0x080 */ struct RfuBlockSend recvBlock[MAX_RFU_PLAYERS]; /* 0x0e4 */ bool8 readyCloseLink[MAX_RFU_PLAYERS]; @@ -170,45 +204,45 @@ struct RfuManager /* 0x0f2 */ u16 packet[RFU_PACKET_SIZE]; /* 0x0fe */ u16 resendExitStandbyTimer; /* 0x100 */ u16 resendExitStandbyCount; - /* 0x102 */ u8 unk_102; - /* 0x104 */ struct RfuTgtData tgtData; + /* 0x102 */ u8 childSendCmdId; + /* 0x104 */ struct RfuTgtData parent; /* 0x124 */ struct RfuRecvQueue recvQueue; /* 0x6a0 */ struct RfuSendQueue sendQueue; /* 0x8d4 */ struct RfuBackupQueue backupQueue; /* 0x8f4 */ vu8 linkRecovered; - /* 0x8f5 */ u8 reconnectedParentIdx; - /* 0x8f6 */ vu8 child_slot; - /* 0x8f7 */ u8 unk_c3f[70]; + /* 0x8f5 */ u8 reconnectParentId; + /* 0x8f6 */ vu8 childSlot; + /* 0x8f7 */ u8 childRecvQueue[COMM_SLOT_LENGTH * MAX_RFU_PLAYERS]; /* 0x93d */ u8 sendStatus; /* 0x93e */ u8 recvStatus; - /* 0x93f */ u8 recvCmds[MAX_RFU_PLAYERS][7][2]; + /* 0x93f */ u8 recvCmds[MAX_RFU_PLAYERS][CMD_LENGTH - 1][2]; /* 0x985 */ u8 parentId; /* 0x986 */ u8 multiplayerId; // childId - /* 0x987 */ u8 unk_ccf; - /* 0x988 */ vu8 sem_UNI_SendRecv; + /* 0x987 */ u8 connectParentFailures; + /* 0x988 */ vu8 childSendCount; /* 0x989 */ u8 partnerSendStatuses[RFU_CHILD_MAX]; /* 0x98d */ u8 partnerRecvStatuses[RFU_CHILD_MAX]; - /* 0x991 */ u8 linkClosing; - /* 0x992 */ u8 unk_cda; - /* 0x993 */ volatile bool8 unk_cdb; - /* 0x994 */ volatile bool8 unk_cdc; - /* 0x995 */ u8 unk_cdd; + /* 0x991 */ bool8 stopNewConnections; + /* 0x992 */ u8 parentSendSlot; + /* 0x993 */ vbool8 parentFinished; + /* 0x994 */ vbool8 parentMain2Failed; + /* 0x995 */ u8 unused5; /* 0x996 */ u8 linkPlayerIdx[RFU_CHILD_MAX]; - /* 0x99a */ u8 bm_PartnerFlags; - /* 0x99b */ u8 bm_DisconnectSlot; - /* 0x99c */ u8 unk_ce4; - /* 0x99d */ u8 bmChatLeaderMaybe; - /* 0x99e */ u8 unionRoomChatters; + /* 0x99a */ u8 parentSlots; + /* 0x99b */ u8 disconnectSlots; + /* 0x99c */ u8 disconnectMode; + /* 0x99d */ u8 nextChildBits; + /* 0x99e */ u8 newChildQueue; /* 0x99f */ u8 acceptSlot_flag; - /* 0x9a0 */ bool8 foundNewLeaderMaybe; - /* 0x9a1 */ u8 unk_ce9; - /* 0x9a2 */ u8 unk_cea[RFU_CHILD_MAX]; - /* 0x9a6 */ u8 unk_cee[RFU_CHILD_MAX]; + /* 0x9a0 */ bool8 playerExchangeActive; + /* 0x9a1 */ u8 incomingChild; + /* 0x9a2 */ u8 numChildRecvErrors[RFU_CHILD_MAX]; + /* 0x9a6 */ u8 childRecvIds[RFU_CHILD_MAX]; }; // size: 0x9AC extern struct RfuGameData gHostRfuGameData; extern u8 gHostRfuUsername[]; -extern struct RfuManager Rfu; +extern struct RfuManager gRfu; // GameFreak signatures void AddTextPrinterToWindow1(const u8 *str); @@ -223,14 +257,14 @@ void MEvent_CreateTask_CardOrNewsOverWireless(u32 arg0); void MEvent_CreateTask_Leader(u32 arg0); void Rfu_SendPacket(void *data); u8 CreateTask_ListenToWireless(void); -void LinkRfu_DestroyIdleTask(void); +void DestroyTask_RfuIdle(void); void InitRFUAPI(void); -void sub_80FB128(bool32 a0); +void RfuSetIgnoreError(bool32 enable); bool32 IsSendingKeysToRfu(void); void ClearLinkRfuCallback(void); -u8 GetRfuPlayerCount(void); +u8 Rfu_GetLinkPlayerCount(void); void StartSendingKeysToRfu(void); -u8 LinkRfu_GetMultiplayerId(void); +u8 Rfu_GetMultiplayerId(void); bool32 Rfu_InitBlockSend(const u8 * src, size_t size); bool8 Rfu_SendBlockRequest(u8 blockRequestType); u8 Rfu_GetBlockReceivedStatus(void); @@ -238,15 +272,15 @@ void Rfu_SetBlockReceivedFlag(u8 linkPlayerId); void Rfu_ResetBlockReceivedFlag(u8 linkPlayerId); bool8 Rfu_IsMaster(void); void ResetLinkRfuGFLayer(void); -bool32 LinkRfuMain1(void); -bool32 LinkRfuMain2(void); +bool32 RfuMain1(void); +bool32 RfuMain2(void); bool32 IsRfuRecvQueueEmpty(void); u32 GetRfuRecvQueueLength(void); void LinkRfu_Shutdown(void); -void LinkRfu_CreateIdleTask(void); -bool8 ToggleLMANlinkRecovery(bool32 enable); +void CreateTask_RfuIdle(void); +bool8 Rfu_SetLinkRecovery(bool32 enable); void var_800D_set_xB(void); -struct RfuGameData *GetHostRFUtgtGname(void); +struct RfuGameData *GetHostRfuGameData(void); void UpdateWirelessStatusIndicatorSprite(void); void InitRFU(void); bool32 RfuHasErrored(void); @@ -262,44 +296,44 @@ bool8 RfuBackupQueue_Dequeue(struct RfuBackupQueue *queue, u8 *dest); void RfuBackupQueue_Enqueue(struct RfuBackupQueue *queue, const u8 *dest); bool8 RfuRecvQueue_Dequeue(struct RfuRecvQueue * queue, u8 *dest); void RfuSendQueue_Enqueue(struct RfuSendQueue * queue, u8 *src); -void InitHostRFUtgtGname(struct RfuGameData *data, u8 activity, bool32 started, s32 child_sprite_genders); +void InitHostRFUtgtGname(struct RfuGameData *data, u8 activity, bool32 started, s32 partnerInfo); void UpdateGameData_GroupLockedIn(bool8 started); bool32 IsRfuSerialNumberValid(u32 serialNo); bool8 IsRfuRecoveringFromLinkLoss(void); bool8 LmanAcceptSlotFlagIsNotZero(void); void LinkRfu_StopManagerAndFinalizeSlots(void); -bool32 sub_80FA5D4(void); -bool32 sub_80FC1CC(void); +bool32 RfuTryDisconnectLeavingChildren(void); +bool32 IsRfuCommunicatingWithAllChildren(void); bool32 WaitRfuState(bool32 a0); -bool32 CheckTrainerHasLeftByIdAndName(u16 trainerId, const u8 *trainerName); -void SendByteToPartnerByIdAndName(u8 a0, u16 a1, const u8 *a2); -u32 WaitSendByteToPartnerByIdAndName(u16 a0, const u8 *a1); -void SetHostRFUtgtGname(u8 activity, u32 child_sprite_genders, u32 a2); +bool32 HasTrainerLeftPartnersList(u16 trainerId, const u8 *trainerName); +void SendRfuStatusToPartner(u8 status, u16 trainerId, const u8 *name); +u32 WaitSendRfuStatusToPartner(u16 trainerId, const u8 *name); +void SetHostRfuGameData(u8 activity, u32 partnerInfo, bool32 startedActivity); void InitializeRfuLinkManager_LinkLeader(u32 availSlots); void RequestDisconnectSlotByTrainerNameAndId(const u8 *trainerName, u16 trainerId); void LinkRfu3_SetGnameUnameFromStaticBuffers(struct RfuGameData *gname, u8 *uname); void InitializeRfuLinkManager_JoinGroup(void); void SendLeaveGroupNotice(void); void CreateTask_RfuReconnectWithParent(const u8 *src, u16 trainerId); -void UpdateGameDataWithActivitySpriteGendersFlag(u8 activity, u32 child_sprite_genders, u32 started); +void UpdateGameData_SetActivity(u8 activity, u32 partnerInfo, u32 startedActivity); void RecordMixTrainerNames(void); void LinkRfu_CreateConnectionAsParent(); void LinkRfu_StopManagerBeforeEnteringChat(); -void SetGnameBufferWonderFlags(bool32 hasNews, bool32 hasCard); -void ClearAndInitHostRFUtgtGname(void); -void sub_80F8FA0(void); -void RfuUpdatePlayerGnameStateAndSend(u32 type, u32 species, u32 level); +void SetHostRfuWonderFlags(bool32 hasNews, bool32 hasCard); +void ResetHostRfuGameData(void); +void StopUnionRoomLinkManager(void); +void SetTradeBoardRegisteredMonInfo(u32 type, u32 species, u32 level); bool32 IsUnionRoomListenTaskActive(void); void InitializeRfuLinkManager_EnterUnionRoom(void); -void sub_80FBD6C(u32 a0); -void sub_80FC114(const u8 *name, struct RfuGameData *structPtr, u8 a2); +void Rfu_DisconnectPlayerById(u32 playerIdx); +void TryConnectToUnionRoomParent(const u8 *name, struct RfuGameData *parent, u8 activity); bool32 PlayerHasMetTrainerBefore(u16 id, u8 *name); bool8 LinkRfu_GetNameIfCompatible(struct RfuGameData *gname, u8 *uname, u8 idx); bool8 LinkRfu_GetNameIfSerial7F7D(struct RfuGameData *gname, u8 *uname, u8 idx); -bool32 RfuHasFoundNewLeader(void); -void Rfu_UnionRoomChat_StopLinkManager(void); -void sub_80FB9D0(void); -void sub_80FB030(u32 a0); +bool32 Rfu_IsPlayerExchangeActive(void); +void Rfu_StopPartnerSearch(void); +void RfuSetNormalDisconnectMode(void); +void SetUnionRoomChatPlayerData(u32 numPlayers); void ClearRecvCommands(void); #include "mevent_server.h" diff --git a/include/mystery_gift_menu.h b/include/mystery_gift_menu.h index bd790b36e..a25cc598f 100644 --- a/include/mystery_gift_menu.h +++ b/include/mystery_gift_menu.h @@ -6,7 +6,7 @@ extern bool8 gGiftIsFromEReader; void MainCB_FreeAllBuffersAndReturnToInitTitleScreen(void); void PrintMysteryGiftOrEReaderTopMenu(bool8, bool32); void c2_mystery_gift(void); -void c2_mystery_gift_e_reader_run(void); +void CB2_MysteryGiftEReader(void); s8 mevent_message_print_and_prompt_yes_no(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, const u8 * str); void MG_DrawTextBorder(u8 windowId); u16 GetMysteryGiftBaseBlock(void); diff --git a/src/battle_controllers.c b/src/battle_controllers.c index ba56b0db1..e877a1c08 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -519,7 +519,7 @@ void TryReceiveLinkBattleData(void) if (gReceivedRemoteLinkPlayers != 0 && (gBattleTypeFlags & BATTLE_TYPE_LINK_IN_BATTLE) && (gLinkPlayers[0].linkType == 0x2211)) { - LinkRfu_DestroyIdleTask(); + DestroyTask_RfuIdle(); for (i = 0; i < GetLinkPlayerCount(); i++) { if (GetBlockReceivedStatus() & gBitTable[i]) diff --git a/src/berry_crush.c b/src/berry_crush.c index d116a112f..ec58ece26 100644 --- a/src/berry_crush.c +++ b/src/berry_crush.c @@ -969,9 +969,9 @@ static u32 QuitBerryCrush(MainCallback callback) #define ERROR_EXIT(exitCallback) \ { \ SetMainCallback2(exitCallback); \ - Rfu.linkman_param[0] = 0; \ - Rfu.linkman_param[1] = 0; \ - Rfu.errorState = 1; \ + gRfu.errorParams[0] = 0; \ + gRfu.errorParams[1] = 0; \ + gRfu.errorState = 1; \ } diff --git a/src/link.c b/src/link.c index 6473de242..e60ebed00 100644 --- a/src/link.c +++ b/src/link.c @@ -227,7 +227,7 @@ bool8 IsWirelessAdapterConnected(void) SetWirelessCommType1(); InitRFUAPI(); - sub_80FB128(TRUE); + RfuSetIgnoreError(TRUE); if (rfu_LMAN_REQBN_softReset_and_checkID() == RFU_ID) { rfu_REQ_stopMode(); @@ -748,21 +748,16 @@ void ClearLinkCallback(void) void ClearLinkCallback_2(void) { if (gWirelessCommType) - { ClearLinkRfuCallback(); - } else - { gLinkCallback = NULL; - } } u8 GetLinkPlayerCount(void) { if (gWirelessCommType) - { - return GetRfuPlayerCount(); - } + return Rfu_GetLinkPlayerCount(); + return EXTRACT_PLAYER_COUNT(gLinkStatus); } @@ -977,7 +972,7 @@ u8 GetMultiplayerId(void) { if (gWirelessCommType == 1) { - return LinkRfu_GetMultiplayerId(); + return Rfu_GetMultiplayerId(); } return SIO_MULTI_CNT->id; } @@ -1647,10 +1642,11 @@ void LinkPlayerFromBlock(u32 who) } } +// When this function returns TRUE the callbacks are skipped bool8 HandleLinkConnection(void) { - bool32 r4; - bool32 r5; + bool32 main1Failed; + bool32 main2Failed; if (gWirelessCommType == 0) { @@ -1663,14 +1659,14 @@ bool8 HandleLinkConnection(void) } else { - r4 = LinkRfuMain1(); - r5 = LinkRfuMain2(); + main1Failed = RfuMain1(); // Always returns FALSE + main2Failed = RfuMain2(); if (IsSendingKeysOverCable() == TRUE) { - if (r4 == TRUE || IsRfuRecvQueueEmpty() || r5) - { + // This will never be reached. + // IsSendingKeysOverCable is always FALSE for wireless communication + if (main1Failed == TRUE || IsRfuRecvQueueEmpty() || main2Failed) return TRUE; - } } } return FALSE; diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 649836276..9257f04b1 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -11,6 +11,40 @@ #include "task.h" #include "constants/union_room.h" +enum { + RFUSTATE_INIT, + RFUSTATE_INIT_END, + RFUSTATE_PARENT_CONNECT, + RFUSTATE_PARENT_CONNECT_END, + RFUSTATE_STOP_MANAGER, + RFUSTATE_STOP_MANAGER_END, + RFUSTATE_CHILD_CONNECT, + RFUSTATE_CHILD_CONNECT_END, + RFUSTATE_UNUSED, + RFUSTATE_RECONNECTED, + RFUSTATE_CONNECTED, + RFUSTATE_CHILD_TRY_JOIN, + RFUSTATE_CHILD_JOINED, + RFUSTATE_UR_PLAYER_EXCHANGE, + RFUSTATE_UR_STOP_MANAGER, + RFUSTATE_UR_STOP_MANAGER_END, + RFUSTATE_UR_FINALIZE, +}; +// These states are used for different purposes +// depending on the link mode (parent, child, union room) +#define RFUSTATE_PARENT_FINALIZE_START 17 +#define RFUSTATE_PARENT_FINALIZE 18 +#define RFUSTATE_UR_CONNECT 17 +#define RFUSTATE_UR_CONNECT_END 18 +#define RFUSTATE_FINALIZED 20 + +// States for the 'receiving' field of RfuBlockSend +enum { + RECV_STATE_READY, + RECV_STATE_RECEIVING, + RECV_STATE_FINISHED, +}; + struct SioInfo { char magic[sizeof("PokemonSioInfo")]; @@ -42,13 +76,13 @@ static u8 sResendBlock8[CMD_LENGTH * 2]; static u16 sResendBlock16[CMD_LENGTH]; struct RfuGameData gHostRfuGameData; -struct RfuManager Rfu; +struct RfuManager gRfu; u8 gHostRfuUsername[PLAYER_NAME_LENGTH + 1]; -static void sub_80F8AA4(void); -static void sub_80F8AEC(void); -static void MscCallback_Child(u16 a0); -static void MSCCallback_SetUnkCDB(u16 a0); +static void InitChildRecvBuffers(void); +static void InitParentSendData(void); +static void MscCallback_Child(u16 REQ_commandID); +static void MSCCallback_Parent(u16 REQ_commandID); static void UpdateBackupQueue(void); static void RfuHandleReceiveCommand(u8 unused); static void ResetSendDataManager(struct RfuBlockSend *data); @@ -58,28 +92,28 @@ static void SendNextBlock(void); static void SendLastBlock(void); static void CallRfuFunc(void); static void UpdateChildStatuses(void); -static s32 GetRfuRecvStatus(void); -static void sub_80FA834(u8 taskId); +static s32 GetJoinGroupStatus(void); +static void Task_PlayerExchange(u8 taskId); static void ClearSelectedLinkPlayerIds(u16 disconnectMask); -static void ValidateAndReceivePokemonSioInfo(void *a0); -static void Task_ExchangeLinkPlayers(u8 taskId); -static void sub_80FACF0(u8 taskId); -static void GetLinkmanErrorParams(u32 msg); -static void sub_80FB564(s32 bmConnectedFlag); -static void sub_80FBB74(void); +static void ValidateAndReceivePokemonSioInfo(void *recvBuffer); +static void Task_PlayerExchangeUpdate(u8 taskId); +static void Task_PlayerExchangeChat(u8 taskId); +static void RfuSetErrorParams(u32 errorInfo); +static void ParentResetChildRecvMetadata(s32 slot); +static void CB2_RfuIdle(void); static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId); static void RfuReqDisconnectSlot(u32 bmDisconnectSlot); -static void sub_80FBE20(u32 a0, u32 a1); -static void sub_80FC028(u8 taskId); +static void SendDisconnectCommand(u32 playersToDisconnect, u32 disconnectMode); +static void Task_TryConnectToUnionRoomParent(u8 taskId); static void Debug_PrintEmpty(void); -static void Task_idle(u8 taskId); +static void Task_Idle(u8 taskId); static const INIT_PARAM sRfuReqConfigTemplate = { .maxMFrame = 4, .MC_TimerCount = 32, .availSlot_flag = 0, .mboot_flag = 0, - .serialNo = 0x0002, + .serialNo = RFU_SERIAL_GAME, .gameName = (void *)&gHostRfuGameData, .userName = gHostRfuUsername, .fastSearchParent_flag = TRUE, @@ -95,76 +129,82 @@ static const u8 sAvailSlots[] = { [4] = AVAIL_SLOT4 }; +#define BLOCK_MASK(bitNum)((1 << (bitNum)) - 1) static const u32 sAllBlocksReceived[] = { - 0x000000, - 0x000001, - 0x000003, - 0x000007, - 0x00000f, - 0x00001f, - 0x00003f, - 0x00007f, - 0x0000ff, - 0x0001ff, - 0x0003ff, - 0x0007ff, - 0x000fff, - 0x001fff, - 0x003fff, - 0x007fff, - 0x00ffff, - 0x01ffff, - 0x03ffff, - 0x07ffff, - 0x0fffff, - 0x1fffff, - 0x3fffff, - 0x7fffff, - 0xffffff + BLOCK_MASK(0), + BLOCK_MASK(1), + BLOCK_MASK(2), + BLOCK_MASK(3), + BLOCK_MASK(4), + BLOCK_MASK(5), + BLOCK_MASK(6), + BLOCK_MASK(7), + BLOCK_MASK(8), + BLOCK_MASK(9), + BLOCK_MASK(10), + BLOCK_MASK(11), + BLOCK_MASK(12), + BLOCK_MASK(13), + BLOCK_MASK(14), + BLOCK_MASK(15), + BLOCK_MASK(16), + BLOCK_MASK(17), + BLOCK_MASK(18), + BLOCK_MASK(19), + BLOCK_MASK(20), + BLOCK_MASK(21), + BLOCK_MASK(22), + BLOCK_MASK(23), + BLOCK_MASK(24), }; +#undef BLOCK_MASK -static const u8 gUnknown_843EC38[] = { +static const u8 sSlotToLinkPlayerTableId[] = { 0, 0, 1, 1, 2, 2, 2, 2, 3 }; -static const u8 sNumSetBits[] = { - [0x0] = 0, - [0x1] = 1, - [0x2] = 1, - [0x3] = 2, - [0x4] = 1, - [0x5] = 2, - [0x6] = 2, - [0x7] = 3, - [0x8] = 1, - [0x9] = 2, - [0xA] = 2, - [0xB] = 3, - [0xC] = 2, - [0xD] = 3, - [0xE] = 3, - [0xF] = 4 +// Effectively just returns the number of bits set in the index value +// Used for masks of the other players, MAX_RFU_PLAYERS - 1 excludes self +static const u8 sPlayerBitsToCount[1 << (MAX_RFU_PLAYERS - 1)] = { + 0, // 0000 + 1, // 0001 + 1, // 0010 + 2, // 0011 + 1, // 0100 + 2, // 0101 + 2, // 0110 + 3, // 0111 + 1, // 1000 + 2, // 1001 + 2, // 1010 + 3, // 1011 + 2, // 1100 + 3, // 1101 + 3, // 1110 + 4 // 1111 }; -static const u8 sNumTrailingZeroes[] = { - [0x0] = 0, - [0x1] = 0, - [0x2] = 1, - [0x3] = 0, - [0x4] = 2, - [0x5] = 0, - [0x6] = 1, - [0x7] = 0, - [0x8] = 3, - [0x9] = 0, - [0xA] = 1, - [0xB] = 0, - [0xC] = 2, - [0xD] = 0, - [0xE] = 1, - [0xF] = 0 +// If the 4 bits representing child slots were an array, this table +// would return the index of the most recently set bit +static const u8 sPlayerBitsToNewChildIdx[1 << (MAX_RFU_PLAYERS - 1)] = { + 0, // 0000 + 0, // 0001 + 1, // 0010 + 0, // 0011 + 2, // 0100 + 0, // 0101 + 1, // 0110 + 0, // 0111 + 3, // 1000 + 0, // 1001 + 1, // 1010 + 0, // 1011 + 2, // 1100 + 0, // 1101 + 1, // 1110 + 0 // 1111 }; static const struct BlockRequest sBlockRequests[] = { @@ -176,12 +216,12 @@ static const struct BlockRequest sBlockRequests[] = { }; static const u16 sAcceptedSerialNos[] = { - 0x0002, // Pokemon FR/LG/EM - RFU_SERIAL_7F7D, - 0xFFFF + RFU_SERIAL_GAME, + RFU_SERIAL_WONDER_DISTRIBUTOR, + RFU_SERIAL_END }; -static const char sUnref_843EC92[][15] = { +static const char sASCII_RfuCmds[][15] = { "RFU WAIT", "RFU BOOT", "RFU ERROR", @@ -195,7 +235,7 @@ static const char sUnref_843EC92[][15] = { "RFU CP POLL" }; -static const char sUnref_843ED37[][16] = { +static const char sASCII_RecoverCmds[][16] = { " ", "RECOVER START ", "DISSCONECT ", @@ -203,18 +243,19 @@ static const char sUnref_843ED37[][16] = { "RECOVER FAILED" }; -static const TaskFunc gUnknown_843ED88[] = { - sub_80FA834, - Task_ExchangeLinkPlayers, - sub_80FACF0 +// List of additional tasks to destroy (if active) when the RFU shuts down +static const TaskFunc sShutdownTasks[] = { + Task_PlayerExchange, + Task_PlayerExchangeUpdate, + Task_PlayerExchangeChat }; static void Debug_PrintString(const void *string, u8 x, u8 y) { - // debug? + } -static void Debug_PrintNum(u16 num, u8 x, u8 y, u8 ndigits) +static void Debug_PrintNum(u16 num, u8 x, u8 y, u8 numDigits) { } @@ -222,21 +263,17 @@ static void Debug_PrintNum(u16 num, u8 x, u8 y, u8 ndigits) void ResetLinkRfuGFLayer(void) { s32 i; - u8 errorState_bak = Rfu.errorState; - CpuFill16(0, &Rfu, sizeof Rfu); - Rfu.parent_child = MODE_NEUTRAL; - Rfu.errorState = errorState_bak; - if (Rfu.errorState != 4) - { - Rfu.errorState = 0; - } + u8 errorState = gRfu.errorState; + CpuFill16(0, &gRfu, sizeof gRfu); + gRfu.parentChild = MODE_NEUTRAL; + gRfu.errorState = errorState; + if (gRfu.errorState != RFU_ERROR_STATE_IGNORE) + gRfu.errorState = RFU_ERROR_STATE_NONE; for (i = 0; i < MAX_RFU_PLAYERS; i++) - { - ResetSendDataManager(&Rfu.recvBlock[i]); - } - ResetSendDataManager(&Rfu.sendBlock); - RfuRecvQueue_Reset(&Rfu.recvQueue); - RfuSendQueue_Reset(&Rfu.sendQueue); + ResetSendDataManager(&gRfu.recvBlock[i]); + ResetSendDataManager(&gRfu.sendBlock); + RfuRecvQueue_Reset(&gRfu.recvQueue); + RfuSendQueue_Reset(&gRfu.sendQueue); CpuFill16(0, gSendCmd, sizeof gSendCmd); CpuFill16(0, gRecvCmds, sizeof gRecvCmds); CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers); @@ -257,149 +294,145 @@ void InitRFU(void) void InitRFUAPI(void) { - if (!rfu_initializeAPI(sRfuAPIBuffer, RFU_API_BUFF_SIZE_RAM, gIntrTable + 1, TRUE)) + if (!rfu_initializeAPI(sRfuAPIBuffer, RFU_API_BUFF_SIZE_RAM, &gIntrTable[1], TRUE)) { gLinkType = 0; // ClearSavedLinkPlayers(); // Em fix - sub_80FB128(FALSE); + RfuSetIgnoreError(FALSE); ResetLinkRfuGFLayer(); - rfu_setTimerInterrupt(3, gIntrTable + 2); + rfu_setTimerInterrupt(3, &gIntrTable[2]); } } -static void Task_LinkLeaderSearchForChildren(u8 taskId) +static void Task_ParentSearchForChildren(u8 taskId) { UpdateChildStatuses(); - switch (Rfu.state) + switch (gRfu.state) { - case 0: + case RFUSTATE_INIT: rfu_LMAN_initializeRFU(&sRfuReqConfig); - Rfu.state = 1; + gRfu.state = RFUSTATE_INIT_END; gTasks[taskId].data[1] = 1; break; - case 1: + case RFUSTATE_INIT_END: break; - case 2: - rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16 *)sAcceptedSerialNos); - Rfu.state = 3; + case RFUSTATE_PARENT_CONNECT: + rfu_LMAN_establishConnection(gRfu.parentChild, 0, 240, (u16 *)sAcceptedSerialNos); + gRfu.state = RFUSTATE_PARENT_CONNECT_END; gTasks[taskId].data[1] = 6; break; - case 3: + case RFUSTATE_PARENT_CONNECT_END: break; - case 4: + case RFUSTATE_STOP_MANAGER: rfu_LMAN_stopManager(FALSE); - Rfu.state = 5; + gRfu.state = RFUSTATE_STOP_MANAGER_END; break; - case 5: + case RFUSTATE_STOP_MANAGER_END: break; - case 18: - Rfu.unk_cdb = FALSE; - rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); - sub_80F8AA4(); - sub_80F8AEC(); - Rfu.state = 20; + case RFUSTATE_PARENT_FINALIZE: + gRfu.parentFinished = FALSE; + rfu_LMAN_setMSCCallback(MSCCallback_Parent); + InitChildRecvBuffers(); + InitParentSendData(); + gRfu.state = RFUSTATE_FINALIZED; gTasks[taskId].data[1] = 8; - CreateTask(sub_80FA834, 5); + CreateTask(Task_PlayerExchange, 5); DestroyTask(taskId); break; } } -static u8 CountTrailingZeroes(u8 acceptSlot) +static u8 Rfu_GetIndexOfNewestChild(u8 bits) { - return sNumTrailingZeroes[acceptSlot]; + return sPlayerBitsToNewChildIdx[bits]; } -static void ReassignPartnerIds(s32 before, s32 after) +static void SetLinkPlayerIdsFromSlots(s32 baseSlots, s32 addSlots) { u8 i; - u8 r4 = 1; - s32 beforeBak = before; - s32 r6 = 0; - if (after == -1) + u8 baseId = 1; + s32 baseSlotsCopy = baseSlots; + s32 newId = 0; + if (addSlots == -1) { - // First Time Init - // UB: linkPlayerIdx may be uninitialized - for (i = 0; i < RFU_CHILD_MAX; before >>= 1, i++) + // Initialize + for (i = 0; i < RFU_CHILD_MAX; baseSlots >>= 1, i++) { - if (before & 1) + if (baseSlots & 1) { - Rfu.linkPlayerIdx[i] = r4; - r4++; + gRfu.linkPlayerIdx[i] = baseId; + baseId++; } } } else { - // Delete before flags - for (i = 0; i < RFU_CHILD_MAX; beforeBak >>= 1, i++) + // Clear id for any empty slot + for (i = 0; i < RFU_CHILD_MAX; baseSlotsCopy >>= 1, i++) { - if (!(beforeBak & 1)) - { - Rfu.linkPlayerIdx[i] = 0; - } + if (!(baseSlotsCopy & 1)) + gRfu.linkPlayerIdx[i] = 0; } - // Get highest retained index - for (r4 = 4; r4 != 0; r4--) + + // Get starting id by checking existing slots + for (baseId = RFU_CHILD_MAX; baseId != 0; baseId--) { - for (i = 0; i < RFU_CHILD_MAX && Rfu.linkPlayerIdx[i] != r4; i++); - if (i == 4) - { - r6 = r4; - } + for (i = 0; i < RFU_CHILD_MAX && gRfu.linkPlayerIdx[i] != baseId; i++) + ; + if (i == RFU_CHILD_MAX) + newId = baseId; } - // Replace with new flags - for (after &= ~before, i = 0; i < RFU_CHILD_MAX; after >>= 1, i++) + + // Set id for new slots + for (addSlots &= ~baseSlots, i = 0; i < RFU_CHILD_MAX; addSlots >>= 1, i++) { - if (after & 1) - { - Rfu.linkPlayerIdx[i] = r6++; - } + if (addSlots & 1) + gRfu.linkPlayerIdx[i] = newId++; } } } -static void Task_JoinGroupSearchForParent(u8 taskId) +static void Task_ChildSearchForParent(u8 taskId) { - switch (Rfu.state) + switch (gRfu.state) { - case 0: + case RFUSTATE_INIT: rfu_LMAN_initializeRFU((INIT_PARAM*)&sRfuReqConfigTemplate); - Rfu.state = 1; + gRfu.state = RFUSTATE_INIT_END; gTasks[taskId].data[1] = 1; break; - case 1: + case RFUSTATE_INIT_END: break; - case 6: - rfu_LMAN_establishConnection(Rfu.parent_child, 0, 240, (u16 *)sAcceptedSerialNos); - Rfu.state = 7; + case RFUSTATE_CHILD_CONNECT: + rfu_LMAN_establishConnection(gRfu.parentChild, 0, 240, (u16 *)sAcceptedSerialNos); + gRfu.state = RFUSTATE_CHILD_CONNECT_END; gTasks[taskId].data[1] = 7; break; - case 7: + case RFUSTATE_CHILD_CONNECT_END: break; - case 9: + case RFUSTATE_RECONNECTED: gTasks[taskId].data[1] = 10; break; - case 11: - switch (GetRfuRecvStatus()) + case RFUSTATE_CHILD_TRY_JOIN: + switch (GetJoinGroupStatus()) { case RFU_STATUS_JOIN_GROUP_OK: - Rfu.state = 12; + gRfu.state = RFUSTATE_CHILD_JOINED; break; case RFU_STATUS_JOIN_GROUP_NO: case RFU_STATUS_LEAVE_GROUP: rfu_LMAN_requestChangeAgbClockMaster(); - Rfu.unk_ce4 = 2; + gRfu.disconnectMode = RFU_DISCONNECT_NORMAL; DestroyTask(taskId); break; } break; - case 12: + case RFUSTATE_CHILD_JOINED: { - u8 bmChildSlot = 1 << Rfu.child_slot; - rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, Rfu.child_slot); - rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); - rfu_UNI_setSendData(bmChildSlot, Rfu.lastCmdBeforeCommInterrupt, sizeof(Rfu.lastCmdBeforeCommInterrupt)); + u8 bmChildSlot = 1 << gRfu.childSlot; + rfu_clearSlot(TYPE_NI_SEND | TYPE_NI_RECV, gRfu.childSlot); + rfu_setRecvBuffer(TYPE_UNI, gRfu.childSlot, gRfu.childRecvQueue, sizeof(gRfu.childRecvQueue)); + rfu_UNI_setSendData(bmChildSlot, gRfu.childSendBuffer, sizeof(gRfu.childSendBuffer)); gTasks[taskId].data[1] = 8; DestroyTask(taskId); if (!sRfuDebug.childJoined) @@ -407,13 +440,13 @@ static void Task_JoinGroupSearchForParent(u8 taskId) Debug_PrintEmpty(); sRfuDebug.childJoined++; } - CreateTask(sub_80FA834, 5); + CreateTask(Task_PlayerExchange, 5); break; } } } -static void sub_80F8AA4(void) +static void InitChildRecvBuffers(void) { u8 i; u8 acceptSlot = lman.acceptSlot_flag; @@ -421,79 +454,77 @@ static void sub_80F8AA4(void) { if (acceptSlot & 1) { - rfu_setRecvBuffer(TYPE_UNI, i, Rfu.main_UNI_recvBuffer[i], sizeof(Rfu.main_UNI_recvBuffer[i])); + rfu_setRecvBuffer(TYPE_UNI, i, gRfu.childRecvBuffer[i], sizeof(gRfu.childRecvBuffer[i])); rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, i); } acceptSlot >>= 1; } } -static void sub_80F8AEC(void) +static void InitParentSendData(void) { u8 acceptSlot = lman.acceptSlot_flag; - rfu_UNI_setSendData(acceptSlot, Rfu.recvCmds, sizeof(Rfu.recvCmds)); - Rfu.unk_cda = CountTrailingZeroes(acceptSlot); - Rfu.bm_PartnerFlags = acceptSlot; - ReassignPartnerIds(acceptSlot, -1); - Rfu.parent_child = MODE_PARENT; + rfu_UNI_setSendData(acceptSlot, gRfu.recvCmds, sizeof(gRfu.recvCmds)); + gRfu.parentSendSlot = Rfu_GetIndexOfNewestChild(acceptSlot); + gRfu.parentSlots = acceptSlot; + SetLinkPlayerIdsFromSlots(acceptSlot, -1); + gRfu.parentChild = MODE_PARENT; } -static void Task_LinkRfu_UnionRoomListen(u8 taskId) +#define tConnectingForChat data[7] + +static void Task_UnionRoomListen(u8 taskId) { - if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM) && RfuGetStatus() == 4) + if (GetHostRfuGameData()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM) && RfuGetStatus() == RFU_STATUS_NEW_CHILD_DETECTED) { rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); RfuSetStatus(RFU_STATUS_OK, 0); } - switch (Rfu.state) + switch (gRfu.state) { - case 0: + case RFUSTATE_INIT: rfu_LMAN_initializeRFU(&sRfuReqConfig); - Rfu.state = 1; + gRfu.state = RFUSTATE_INIT_END; gTasks[taskId].data[1] = 1; break; - case 1: + case RFUSTATE_INIT_END: break; - case 17: + case RFUSTATE_UR_CONNECT: rfu_LMAN_establishConnection(MODE_P_C_SWITCH, 0, 240, (u16 *)sAcceptedSerialNos); rfu_LMAN_setMSCCallback(MscCallback_Child); - Rfu.state = 18; + gRfu.state = RFUSTATE_UR_CONNECT_END; break; - case 18: + case RFUSTATE_UR_CONNECT_END: break; - case 13: - if (rfu_UNI_setSendData(1 << Rfu.child_slot, Rfu.lastCmdBeforeCommInterrupt, sizeof(Rfu.lastCmdBeforeCommInterrupt)) == 0) + case RFUSTATE_UR_PLAYER_EXCHANGE: + if (rfu_UNI_setSendData(1 << gRfu.childSlot, gRfu.childSendBuffer, sizeof(gRfu.childSendBuffer)) == 0) { - Rfu.parent_child = MODE_CHILD; + gRfu.parentChild = MODE_CHILD; DestroyTask(taskId); - if (gTasks[taskId].data[7]) - { - CreateTask(sub_80FACF0, 1); - } + if (gTasks[taskId].tConnectingForChat) + CreateTask(Task_PlayerExchangeChat, 1); else - { - CreateTask(sub_80FA834, 5); - } + CreateTask(Task_PlayerExchange, 5); } break; - case 14: - rfu_LMAN_stopManager(0); - Rfu.state = 15; + case RFUSTATE_UR_STOP_MANAGER: + rfu_LMAN_stopManager(FALSE); + gRfu.state = RFUSTATE_UR_STOP_MANAGER_END; break; - case 15: + case RFUSTATE_UR_STOP_MANAGER_END: break; - case 16: - Rfu.unk_cdb = FALSE; - rfu_LMAN_setMSCCallback(MSCCallback_SetUnkCDB); - UpdateGameData_GroupLockedIn(1); - sub_80F8AA4(); - sub_80F8AEC(); - Rfu.state = 20; + case RFUSTATE_UR_FINALIZE: + gRfu.parentFinished = FALSE; + rfu_LMAN_setMSCCallback(MSCCallback_Parent); + UpdateGameData_GroupLockedIn(TRUE); + InitChildRecvBuffers(); + InitParentSendData(); + gRfu.state = RFUSTATE_FINALIZED; gTasks[taskId].data[1] = 8; - Rfu.parent_child = MODE_PARENT; - CreateTask(sub_80FA834, 5); - Rfu.foundNewLeaderMaybe = TRUE; + gRfu.parentChild = MODE_PARENT; + CreateTask(Task_PlayerExchange, 5); + gRfu.playerExchangeActive = TRUE; DestroyTask(taskId); break; } @@ -509,31 +540,32 @@ void LinkRfu_StopManagerBeforeEnteringChat(void) rfu_LMAN_stopManager(FALSE); } -static void MscCallback_Child(u16 unused) +// Argument is provided by the RFU and is unused. +static void MscCallback_Child(u16 REQ_commandID) { s32 i; - for (i = 0; i < BACKUP_QUEUE_SLOT_LENGTH; i++) - { - Rfu.lastCmdBeforeCommInterrupt[i] = 0; - } + for (i = 0; i < COMM_SLOT_LENGTH; i++) + gRfu.childSendBuffer[i] = 0; + rfu_REQ_recvData(); rfu_waitREQComplete(); - if (gRfuSlotStatusUNI[Rfu.child_slot]->recv.newDataFlag) + if (gRfuSlotStatusUNI[gRfu.childSlot]->recv.newDataFlag) { - Rfu.sem_UNI_SendRecv++; - RfuRecvQueue_Enqueue(&Rfu.recvQueue, Rfu.unk_c3f); + gRfu.childSendCount++; + RfuRecvQueue_Enqueue(&gRfu.recvQueue, gRfu.childRecvQueue); sRfuDebug.recvCount++; UpdateBackupQueue(); - rfu_UNI_readySendData(Rfu.child_slot); - rfu_UNI_clearRecvNewDataFlag(Rfu.child_slot); + rfu_UNI_readySendData(gRfu.childSlot); + rfu_UNI_clearRecvNewDataFlag(gRfu.childSlot); } rfu_LMAN_REQ_sendData(TRUE); } -static void MSCCallback_SetUnkCDB(u16 unused) +// Argument is provided by the RFU and is unused. +static void MSCCallback_Parent(u16 REQ_commandID) { - Rfu.unk_cdb = TRUE; + gRfu.parentFinished = TRUE; } void LinkRfu_Shutdown(void) @@ -544,125 +576,125 @@ void LinkRfu_Shutdown(void) return; rfu_LMAN_powerDownRFU(); - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) { - if (FuncIsActiveTask(Task_LinkLeaderSearchForChildren) == TRUE) + // Stop parent searching for children + if (FuncIsActiveTask(Task_ParentSearchForChildren) == TRUE) { - DestroyTask(Rfu.searchTaskId); + DestroyTask(gRfu.searchTaskId); ResetLinkRfuGFLayer(); } } - else if (Rfu.parent_child == MODE_CHILD) + else if (gRfu.parentChild == MODE_CHILD) { - if (FuncIsActiveTask(Task_JoinGroupSearchForParent) == TRUE) + // Stop child searching for parent + if (FuncIsActiveTask(Task_ChildSearchForParent) == TRUE) { - DestroyTask(Rfu.searchTaskId); + DestroyTask(gRfu.searchTaskId); ResetLinkRfuGFLayer(); } } - else if (Rfu.parent_child == 2) + else if (gRfu.parentChild == MODE_P_C_SWITCH) { - if (FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) + // Stop parent-child switching mode (union room) + if (FuncIsActiveTask(Task_UnionRoomListen) == TRUE) { - DestroyTask(Rfu.searchTaskId); + DestroyTask(gRfu.searchTaskId); ResetLinkRfuGFLayer(); } } - for (i = 0; i < NELEMS(gUnknown_843ED88); i++) + + // Destroy additional tasks + for (i = 0; i < ARRAY_COUNT(sShutdownTasks); i++) { - if (FuncIsActiveTask(gUnknown_843ED88[i]) == TRUE) - { - DestroyTask(FindTaskIdByFunc(gUnknown_843ED88[i])); - } + if (FuncIsActiveTask(sShutdownTasks[i]) == TRUE) + DestroyTask(FindTaskIdByFunc(sShutdownTasks[i])); } } -static void CreateTask_LinkLeaderSearchForChildren(void) +static void CreateTask_ParentSearchForChildren(void) { if (QL_IS_PLAYBACK_STATE) return; - Rfu.searchTaskId = CreateTask(Task_LinkLeaderSearchForChildren, 1); + gRfu.searchTaskId = CreateTask(Task_ParentSearchForChildren, 1); } -static bool8 ContactedByParentAttemptingToReconnect(void) +// If no parent ID (or if child connection not ready) can't reconnect with parent yet +static bool8 CanTryReconnectParent(void) { - if (Rfu.state == 7 && Rfu.parentId) + if (gRfu.state == RFUSTATE_CHILD_CONNECT_END && gRfu.parentId) + return TRUE; + return FALSE; +} + +static bool32 TryReconnectParent(void) +{ + if (gRfu.state == RFUSTATE_CHILD_CONNECT_END && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[gRfu.reconnectParentId].id, 240)) { + gRfu.state = RFUSTATE_RECONNECTED; return TRUE; } return FALSE; } -static bool32 IsParentSuccessfullyReconnected(void) -{ - if (Rfu.state == 7 && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[Rfu.reconnectedParentIdx].id, 240)) - { - Rfu.state = 9; - return TRUE; - } - return FALSE; -} - -static void CreateTask_JoinGroupSearchForParent(void) +static void CreateTask_ChildSearchForParent(void) { if (QL_IS_PLAYBACK_STATE) return; - Rfu.searchTaskId = CreateTask(Task_JoinGroupSearchForParent, 1); + gRfu.searchTaskId = CreateTask(Task_ChildSearchForParent, 1); } bool8 LmanAcceptSlotFlagIsNotZero(void) { if (lman.acceptSlot_flag) - { return TRUE; - } return FALSE; } void LinkRfu_StopManagerAndFinalizeSlots(void) { - Rfu.state = 4; - Rfu.acceptSlot_flag = lman.acceptSlot_flag; + gRfu.state = RFUSTATE_STOP_MANAGER; + gRfu.acceptSlot_flag = lman.acceptSlot_flag; } bool32 WaitRfuState(bool32 force) { - if (Rfu.state == 17 || force) + if (gRfu.state == RFUSTATE_PARENT_FINALIZE_START || force) { - Rfu.state = 18; + gRfu.state = RFUSTATE_PARENT_FINALIZE; return TRUE; } return FALSE; } -void sub_80F8FA0(void) +void StopUnionRoomLinkManager(void) { - Rfu.state = 14; + gRfu.state = RFUSTATE_UR_STOP_MANAGER; } // Unused -static void sub_80F8FAC(u8 a0) +static void ReadySendDataForSlots(u8 slots) { u8 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if (a0 & 1) + if (slots & 1) { rfu_UNI_readySendData(i); break; } - a0 >>= 1; + slots >>= 1; } } -static void MoveRecvCmdsToRfuBuffer(void) +static void ReadAllPlayerRecvCmds(void) { s32 i, j; for (i = 0; i < MAX_RFU_PLAYERS; i++) { - struct RfuManager *ptr = &Rfu; + struct RfuManager *ptr = &gRfu; for (j = 0; j < CMD_LENGTH - 1; j++) { ptr->recvCmds[i][j][1] = gRecvCmds[i][j] >> 8; @@ -672,37 +704,31 @@ static void MoveRecvCmdsToRfuBuffer(void) CpuFill16(0, gRecvCmds, sizeof gRecvCmds); } -static void MoveSendCmdToFirstRecvCmd(void) +static void MoveSendCmdToRecv(void) { s32 i; for (i = 0; i < CMD_LENGTH - 1; i++) - { gRecvCmds[0][i] = gSendCmd[i]; - } + for (i = 0; i < CMD_LENGTH - 1; i++) - { gSendCmd[i] = 0; - } } static void UpdateBackupQueue(void) { - if (Rfu.linkRecovered) + if (gRfu.linkRecovered) { - bool8 backupEmpty = RfuBackupQueue_Dequeue(&Rfu.backupQueue, Rfu.lastCmdBeforeCommInterrupt); - if (Rfu.backupQueue.count == 0) - { - Rfu.linkRecovered = FALSE; - } + bool8 backupEmpty = RfuBackupQueue_Dequeue(&gRfu.backupQueue, gRfu.childSendBuffer); + if (gRfu.backupQueue.count == 0) + gRfu.linkRecovered = FALSE; + if (backupEmpty) - { return; - } } - if (!Rfu.linkRecovered) + if (!gRfu.linkRecovered) { - RfuSendQueue_Dequeue(&Rfu.sendQueue, Rfu.lastCmdBeforeCommInterrupt); - RfuBackupQueue_Enqueue(&Rfu.backupQueue, Rfu.lastCmdBeforeCommInterrupt); + RfuSendQueue_Dequeue(&gRfu.sendQueue, gRfu.childSendBuffer); + RfuBackupQueue_Enqueue(&gRfu.backupQueue, gRfu.childSendBuffer); } } @@ -712,25 +738,19 @@ bool32 IsRfuRecvQueueEmpty(void) s32 j; if (gRfuLinkStatus->sendSlotUNIFlag == 0) - { return FALSE; - } + for (i = 0; i < MAX_RFU_PLAYERS; i++) - { for (j = 0; j < CMD_LENGTH - 1; j++) - { if (gRecvCmds[i][j] != 0) - { return FALSE; - } - } - } + return TRUE; } -static bool32 sub_80F911C(void) +static bool32 RfuMain1_Parent(void) { - if (Rfu.state < 20) + if (gRfu.state < RFUSTATE_FINALIZED) { rfu_REQ_recvData(); rfu_waitREQComplete(); @@ -738,19 +758,19 @@ static bool32 sub_80F911C(void) } else { - Rfu.unk_cdb = FALSE; - if ((Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag) == Rfu.bm_PartnerFlags && (Rfu.bm_PartnerFlags & gRfuLinkStatus->connSlotFlag)) + gRfu.parentFinished = FALSE; + if ((gRfu.parentSlots & gRfuLinkStatus->connSlotFlag) == gRfu.parentSlots && (gRfu.parentSlots & gRfuLinkStatus->connSlotFlag)) { - if (!Rfu.unk_cdc) + if (!gRfu.parentMain2Failed) { - if (Rfu.bm_DisconnectSlot) + if (gRfu.disconnectSlots) { - RfuReqDisconnectSlot(Rfu.bm_DisconnectSlot); - Rfu.bm_DisconnectSlot = 0; - if (Rfu.unk_ce4 == 1) + RfuReqDisconnectSlot(gRfu.disconnectSlots); + gRfu.disconnectSlots = 0; + if (gRfu.disconnectMode == RFU_DISCONNECT_ERROR) { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x8000); - GetLinkmanErrorParams(0x8000); + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_8); + RfuSetErrorParams(F_RFU_ERROR_8); return FALSE; } if (!lman.acceptSlot_flag) @@ -760,67 +780,65 @@ static bool32 sub_80F911C(void) return FALSE; } } - MoveRecvCmdsToRfuBuffer(); - rfu_UNI_readySendData(Rfu.unk_cda); + ReadAllPlayerRecvCmds(); + rfu_UNI_readySendData(gRfu.parentSendSlot); rfu_LMAN_REQ_sendData(TRUE); } else { rfu_REQ_PARENT_resumeRetransmitAndChange(); } - Rfu.unk_0e = TRUE; + gRfu.runParentMain2 = TRUE; } } return FALSE; } -static bool32 sub_80F9204(void) +static bool32 RfuMain2_Parent(void) { u16 i; u16 flags; u8 r0; u16 j; - u8 retval; + bool8 failed; - if (Rfu.state >= 20 && Rfu.unk_0e == TRUE) + if (gRfu.state >= RFUSTATE_FINALIZED && gRfu.runParentMain2 == TRUE) { rfu_waitREQComplete(); - while (!Rfu.unk_cdb) + while (!gRfu.parentFinished) { - if (Rfu.errorState != 0) - { + if (gRfu.errorState != RFU_ERROR_STATE_NONE) return FALSE; - } } rfu_REQ_recvData(); rfu_waitREQComplete(); - if ((lman.parentAck_flag & Rfu.bm_PartnerFlags) == Rfu.bm_PartnerFlags) + if ((lman.parentAck_flag & gRfu.parentSlots) == gRfu.parentSlots) { - Rfu.unk_cdc = 0; + gRfu.parentMain2Failed = FALSE; sRfuDebug.recvCount++; flags = lman.acceptSlot_flag; for (i = 0; i < RFU_CHILD_MAX; i++) { if (flags & 1) { - if (Rfu.main_UNI_recvBuffer[i][1]) + if (gRfu.childRecvBuffer[i][1]) { - if (Rfu.unk_cee[i] != 0xFF && (Rfu.main_UNI_recvBuffer[i][0] >> 5) != ((Rfu.unk_cee[i] + 1) & 7)) + if (gRfu.childRecvIds[i] != 0xFF && (gRfu.childRecvBuffer[i][0] >> 5) != ((gRfu.childRecvIds[i] + 1) & 7)) { - if (++Rfu.unk_cea[i] > 4) - GetLinkmanErrorParams(0x8100); + if (++gRfu.numChildRecvErrors[i] > 4) + RfuSetErrorParams(F_RFU_ERROR_8 | F_RFU_ERROR_1); } else { - Rfu.unk_cee[i] = Rfu.main_UNI_recvBuffer[i][0] / 32; - Rfu.unk_cea[i] = 0; - Rfu.main_UNI_recvBuffer[i][0] &= 0x1f; - r0 = Rfu.linkPlayerIdx[i]; - for (j = 0; j < 7; j++) + gRfu.childRecvIds[i] = gRfu.childRecvBuffer[i][0] / 32; + gRfu.numChildRecvErrors[i] = 0; + gRfu.childRecvBuffer[i][0] &= 0x1f; + r0 = gRfu.linkPlayerIdx[i]; + for (j = 0; j < CMD_LENGTH - 1; j++) { - gRecvCmds[r0][j] = (Rfu.main_UNI_recvBuffer[i][(j << 1) + 1] << 8) | Rfu.main_UNI_recvBuffer[i][(j << 1) + 0]; - Rfu.main_UNI_recvBuffer[i][(j << 1) + 1] = 0; - Rfu.main_UNI_recvBuffer[i][(j << 1) + 0] = 0; + gRecvCmds[r0][j] = (gRfu.childRecvBuffer[i][(j << 1) + 1] << 8) | gRfu.childRecvBuffer[i][(j << 1) + 0]; + gRfu.childRecvBuffer[i][(j << 1) + 1] = 0; + gRfu.childRecvBuffer[i][(j << 1) + 0] = 0; } } } @@ -828,62 +846,60 @@ static bool32 sub_80F9204(void) } flags >>= 1; } - MoveSendCmdToFirstRecvCmd(); + MoveSendCmdToRecv(); RfuHandleReceiveCommand(0); CallRfuFunc(); - if (Rfu.bmChatLeaderMaybe && !Rfu.linkClosing) + if (gRfu.nextChildBits && !gRfu.stopNewConnections) { sRfuDebug.unkFlag = FALSE; - rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, Rfu.unk_cda); + rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, gRfu.parentSendSlot); for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((Rfu.bmChatLeaderMaybe >> i) & 1) - { - rfu_setRecvBuffer(TYPE_UNI, i, Rfu.main_UNI_recvBuffer[i], sizeof(Rfu.main_UNI_recvBuffer[i])); - } + if ((gRfu.nextChildBits >> i) & 1) + rfu_setRecvBuffer(TYPE_UNI, i, gRfu.childRecvBuffer[i], sizeof(gRfu.childRecvBuffer[i])); } - ReassignPartnerIds(Rfu.bm_PartnerFlags, Rfu.bm_PartnerFlags | Rfu.bmChatLeaderMaybe); - Rfu.unk_ce9 = Rfu.bmChatLeaderMaybe; - Rfu.bm_PartnerFlags |= Rfu.bmChatLeaderMaybe; - Rfu.bmChatLeaderMaybe = 0; - rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, sizeof(Rfu.recvCmds)); - Rfu.unk_cda = CountTrailingZeroes(Rfu.bm_PartnerFlags); - CreateTask(Task_ExchangeLinkPlayers, 0); + SetLinkPlayerIdsFromSlots(gRfu.parentSlots, gRfu.parentSlots | gRfu.nextChildBits); + gRfu.incomingChild = gRfu.nextChildBits; + gRfu.parentSlots |= gRfu.nextChildBits; + gRfu.nextChildBits = 0; + rfu_UNI_setSendData(gRfu.parentSlots, gRfu.recvCmds, sizeof(gRfu.recvCmds)); + gRfu.parentSendSlot = Rfu_GetIndexOfNewestChild(gRfu.parentSlots); + CreateTask(Task_PlayerExchangeUpdate, 0); } } else { - Rfu.unk_cdc = 1; - Rfu.unk_0e = FALSE; + gRfu.parentMain2Failed = TRUE; + gRfu.runParentMain2 = FALSE; } - Rfu.unk_0e = FALSE; + gRfu.runParentMain2 = FALSE; } - retval = Rfu.unk_cdc; - return gRfuLinkStatus->sendSlotUNIFlag ? retval & 1 : FALSE; + failed = gRfu.parentMain2Failed; + return gRfuLinkStatus->sendSlotUNIFlag ? failed & 1 : FALSE; } -static void RfuBufferSendCmd(u16 *sendCmd, u8 *rfuSendBuf) +static void ChildBuildSendCmd(u16 *sendCmd, u8 *dst) { s32 i; if (sendCmd[0]) { - sendCmd[0] |= (Rfu.unk_102 << 5); - Rfu.unk_102 = (Rfu.unk_102 + 1) & 7; - for (i = 0; i < 7; i++) + sendCmd[0] |= (gRfu.childSendCmdId << 5); + gRfu.childSendCmdId = (gRfu.childSendCmdId + 1) & 7; + for (i = 0; i < CMD_LENGTH - 1; i++) { - rfuSendBuf[2 * i + 1] = sendCmd[i] >> 8; - rfuSendBuf[2 * i + 0] = sendCmd[i]; + dst[2 * i + 1] = sendCmd[i] >> 8; + dst[2 * i + 0] = sendCmd[i]; } } else { - for (i = 0; i < 14; i++) - rfuSendBuf[i] = 0; + for (i = 0; i < 2 * (CMD_LENGTH - 1); i++) + dst[i] = 0; } } -static bool32 RfuProcessEnqueuedRecvBlock(void) +static bool32 RfuMain1_Child(void) { u8 i; u8 j; @@ -891,16 +907,17 @@ static bool32 RfuProcessEnqueuedRecvBlock(void) u8 sendBuf[2 * (CMD_LENGTH - 1)]; u8 status; - RfuRecvQueue_Dequeue(&Rfu.recvQueue, recvBuf); + RfuRecvQueue_Dequeue(&gRfu.recvQueue, recvBuf); for (i = 0; i < MAX_RFU_PLAYERS; i++) { for (j = 0; j < CMD_LENGTH - 1; j++) { - gRecvCmds[i][j] = (recvBuf[i * 14 + (j << 1) + 1] << 8) | recvBuf[i * 14 + (j << 1) + 0]; + gRecvCmds[i][j] = (recvBuf[i * COMM_SLOT_LENGTH + (j * 2) + 1] << 8) + | recvBuf[i * COMM_SLOT_LENGTH + (j * 2) + 0]; } } RfuHandleReceiveCommand(0); - if (lman.childClockSlave_flag == 0 && Rfu.unk_ce4) + if (lman.childClockSlave_flag == 0 && gRfu.disconnectMode != RFU_DISCONNECT_NONE) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); @@ -908,24 +925,24 @@ static bool32 RfuProcessEnqueuedRecvBlock(void) if (status != RFU_STATUS_FATAL_ERROR && status != RFU_STATUS_JOIN_GROUP_NO && status != RFU_STATUS_LEAVE_GROUP) - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x9000); + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_8); rfu_clearAllSlot(); gReceivedRemoteLinkPlayers = FALSE; - Rfu.RfuFunc = NULL; - if (Rfu.unk_ce4 == 1) + gRfu.callback = NULL; + if (gRfu.disconnectMode == RFU_DISCONNECT_ERROR) { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x9000); - GetLinkmanErrorParams(0x9000); + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_8); + RfuSetErrorParams(F_RFU_ERROR_5 | F_RFU_ERROR_8); } lman.state = lman.next_state = 0; - Rfu.unk_ce4 = 0; + gRfu.disconnectMode = RFU_DISCONNECT_NONE; } - if (Rfu.sem_UNI_SendRecv) + if (gRfu.childSendCount) { - Rfu.sem_UNI_SendRecv--; + gRfu.childSendCount--; CallRfuFunc(); - RfuBufferSendCmd(gSendCmd, sendBuf); - RfuSendQueue_Enqueue(&Rfu.sendQueue, sendBuf); + ChildBuildSendCmd(gSendCmd, sendBuf); + RfuSendQueue_Enqueue(&gRfu.sendQueue, sendBuf); for (i = 0; i < CMD_LENGTH - 1; i++) gSendCmd[i] = 0; } @@ -936,25 +953,26 @@ static void HandleSendFailure(u8 unused, u32 flags) { s32 i, j, temp; - const u8 *payload = Rfu.sendBlock.payload; - for (i = 0; i < Rfu.sendBlock.count; i++) + const u8 *payload = gRfu.sendBlock.payload; + for (i = 0; i < gRfu.sendBlock.count; i++) { if (!(flags & 1)) { - sResendBlock16[0] = RFUCMD_SEND_BLOCK_STEP | i; - for (j = 0; j < 7; j++) + sResendBlock16[0] = RFUCMD_SEND_BLOCK | i; + for (j = 0; j < CMD_LENGTH - 1; j++) { - temp = j << 1; - sResendBlock16[j + 1] = (payload[12 * i + temp + 1] << 8) | payload[12 * i + temp + 0]; + temp = j * 2; + sResendBlock16[j + 1] = (payload[(COMM_SLOT_LENGTH - 2) * i + temp + 1] << 8) + | payload[(COMM_SLOT_LENGTH - 2) * i + temp + 0]; } - for (j = 0; j < 7; j++) + for (j = 0; j < CMD_LENGTH - 1; j++) { - temp = j << 1; + temp = j * 2; sResendBlock8[temp + 1] = sResendBlock16[j] >> 8; sResendBlock8[temp + 0] = sResendBlock16[j]; } - RfuSendQueue_Enqueue(&Rfu.sendQueue, sResendBlock8); - Rfu.sendBlock.failedFlags |= (1 << i); + RfuSendQueue_Enqueue(&gRfu.sendQueue, sResendBlock8); + gRfu.sendBlock.failedFlags |= (1 << i); } flags >>= 1; } @@ -962,32 +980,30 @@ static void HandleSendFailure(u8 unused, u32 flags) void Rfu_SetBlockReceivedFlag(u8 linkPlayerId) { - if (Rfu.parent_child == MODE_PARENT && linkPlayerId != 0) - Rfu.numBlocksReceived[linkPlayerId] = 1; + if (gRfu.parentChild == MODE_PARENT && linkPlayerId != 0) + gRfu.numBlocksReceived[linkPlayerId] = 1; else - Rfu.blockReceived[linkPlayerId] = TRUE; + gRfu.blockReceived[linkPlayerId] = TRUE; } void Rfu_ResetBlockReceivedFlag(u8 linkPlayerId) { - Rfu.blockReceived[linkPlayerId] = FALSE; - Rfu.recvBlock[linkPlayerId].receiving = RFU_RECV_IDLE; + gRfu.blockReceived[linkPlayerId] = FALSE; + gRfu.recvBlock[linkPlayerId].receiving = RECV_STATE_READY; } -static u8 RfuChildSetReceivedPlayerOrder(const u8 *template) +static u8 LoadLinkPlayerIds(const u8 *ids) { u8 i; - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) return FALSE; for (i = 0; i < RFU_CHILD_MAX; i++) - { - Rfu.linkPlayerIdx[i] = template[i]; - } - return template[Rfu.child_slot]; + gRfu.linkPlayerIdx[i] = ids[i]; + return ids[gRfu.childSlot]; } -static void RfuFunc_SendKeysToRfu(void) +static void SendKeysToRfu(void) { static u8 heldKeyCount; if (gReceivedRemoteLinkPlayers @@ -1000,27 +1016,49 @@ static void RfuFunc_SendKeysToRfu(void) } } -struct RfuGameData *GetHostRFUtgtGname(void) +struct RfuGameData *GetHostRfuGameData(void) { return &gHostRfuGameData; } bool32 IsSendingKeysToRfu(void) { - return Rfu.RfuFunc == RfuFunc_SendKeysToRfu; + return gRfu.callback == SendKeysToRfu; } void StartSendingKeysToRfu(void) { +// This is the original symbol and field name, which is baked into the assert below +#define Rfu gRfu +#define RfuFunc callback AGB_ASSERT_EX(Rfu.RfuFunc == NULL, ABSPATH("rfu.c"), 1473); - Rfu.RfuFunc = RfuFunc_SendKeysToRfu; +#undef RfuFunc +#undef Rfu + + gRfu.callback = SendKeysToRfu; } void ClearLinkRfuCallback(void) { - Rfu.RfuFunc = NULL; + gRfu.callback = NULL; } +/* +static void Rfu_BerryBlenderSendHeldKeys(void) +{ + RfuPrepareSendBuffer(RFUCMD_BLENDER_SEND_KEYS); + if (GetMultiplayerId() == 0) + gSendCmd[BLENDER_COMM_ARROW_POS] = GetBlenderArrowPosition(); + gBerryBlenderKeySendAttempts++; +} + +void Rfu_SetBerryBlenderLinkCallback(void) +{ + if (gRfu.callback == NULL) + gRfu.callback = Rfu_BerryBlenderSendHeldKeys; +} +*/ + static void RfuHandleReceiveCommand(u8 unused) { u16 i; @@ -1028,42 +1066,42 @@ static void RfuHandleReceiveCommand(u8 unused) for (i = 0; i < MAX_RFU_PLAYERS; i++) { - switch (gRecvCmds[i][0] & 0xff00) + switch (gRecvCmds[i][0] & RFUCMD_MASK) { - case RFUCMD_PLAYERS_LIST_2: - if (Rfu.parent_child == MODE_CHILD && gReceivedRemoteLinkPlayers) + case RFUCMD_SEND_PLAYER_IDS_NEW: + if (gRfu.parentChild == MODE_CHILD && gReceivedRemoteLinkPlayers) return; // fallthrough - case RFUCMD_PLAYERS_LIST: + case RFUCMD_SEND_PLAYER_IDS: if (gRfuLinkStatus->parentChild == MODE_CHILD) { - Rfu.playerCount = gRecvCmds[i][1]; - Rfu.multiplayerId = RfuChildSetReceivedPlayerOrder((u8 *)(gRecvCmds[i] + 2)); + gRfu.playerCount = gRecvCmds[i][1]; + gRfu.multiplayerId = LoadLinkPlayerIds((u8 *)(gRecvCmds[i] + 2)); } break; case RFUCMD_SEND_BLOCK_INIT: - if (Rfu.recvBlock[i].receiving == RFU_RECV_IDLE) + if (gRfu.recvBlock[i].receiving == RECV_STATE_READY) { - Rfu.recvBlock[i].next = 0; - Rfu.recvBlock[i].count = gRecvCmds[i][1]; - Rfu.recvBlock[i].owner = gRecvCmds[i][2]; - Rfu.recvBlock[i].receivedFlags = 0; - Rfu.recvBlock[i].receiving = RFU_RECV_RECEIVING; - Rfu.blockReceived[i] = FALSE; + gRfu.recvBlock[i].next = 0; + gRfu.recvBlock[i].count = gRecvCmds[i][1]; + gRfu.recvBlock[i].owner = gRecvCmds[i][2]; + gRfu.recvBlock[i].receivedFlags = 0; + gRfu.recvBlock[i].receiving = RECV_STATE_RECEIVING; + gRfu.blockReceived[i] = FALSE; } break; - case RFUCMD_SEND_BLOCK_STEP: - if (Rfu.recvBlock[i].receiving == RFU_RECV_RECEIVING) + case RFUCMD_SEND_BLOCK: + if (gRfu.recvBlock[i].receiving == RECV_STATE_RECEIVING) { - Rfu.recvBlock[i].next = gRecvCmds[i][0] & 0xff; - Rfu.recvBlock[i].receivedFlags |= (1 << Rfu.recvBlock[i].next); + gRfu.recvBlock[i].next = gRecvCmds[i][0] & ~RFUCMD_MASK; + gRfu.recvBlock[i].receivedFlags |= (1 << gRfu.recvBlock[i].next); for (j = 0; j < 6; j++) - gBlockRecvBuffer[i][Rfu.recvBlock[i].next * 6 + j] = gRecvCmds[i][j + 1]; - if (Rfu.recvBlock[i].receivedFlags == sAllBlocksReceived[Rfu.recvBlock[i].count]) + gBlockRecvBuffer[i][gRfu.recvBlock[i].next * 6 + j] = gRecvCmds[i][j + 1]; + if (gRfu.recvBlock[i].receivedFlags == sAllBlocksReceived[gRfu.recvBlock[i].count]) { - Rfu.recvBlock[i].receiving = RFU_RECV_FINISHED; + gRfu.recvBlock[i].receiving = RECV_STATE_FINISHED; Rfu_SetBlockReceivedFlag(i); - if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers && Rfu.parent_child == MODE_CHILD) + if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers && gRfu.parentChild == MODE_CHILD) ValidateAndReceivePokemonSioInfo(gBlockRecvBuffer); } } @@ -1072,67 +1110,70 @@ static void RfuHandleReceiveCommand(u8 unused) Rfu_InitBlockSend(sBlockRequests[gRecvCmds[i][1]].address, (u16)sBlockRequests[gRecvCmds[i][1]].size); break; case RFUCMD_READY_CLOSE_LINK: - Rfu.readyCloseLink[i] = TRUE; + gRfu.readyCloseLink[i] = TRUE; break; case RFUCMD_READY_EXIT_STANDBY: - if (Rfu.resendExitStandbyCount == gRecvCmds[i][1]) - Rfu.readyExitStandby[i] = TRUE; + if (gRfu.resendExitStandbyCount == gRecvCmds[i][1]) + gRfu.readyExitStandby[i] = TRUE; break; - case RFUCMD_PARENT_DISCONNECT: - if (Rfu.parent_child == MODE_CHILD) + case RFUCMD_DISCONNECT: + if (gRfu.parentChild == MODE_CHILD) { + // Disconnect child if (gReceivedRemoteLinkPlayers) { if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag) { gReceivedRemoteLinkPlayers = FALSE; rfu_LMAN_requestChangeAgbClockMaster(); - Rfu.unk_ce4 = gRecvCmds[i][2]; + gRfu.disconnectMode = gRecvCmds[i][2]; } - Rfu.playerCount = gRecvCmds[i][3]; + gRfu.playerCount = gRecvCmds[i][3]; ClearSelectedLinkPlayerIds(gRecvCmds[i][1]); } } else { - RfuPrepareSendBuffer(RFUCMD_CHILD_DISCONNECT); + // Disconnect parent + RfuPrepareSendBuffer(RFUCMD_DISCONNECT_PARENT); gSendCmd[1] = gRecvCmds[i][1]; gSendCmd[2] = gRecvCmds[i][2]; gSendCmd[3] = gRecvCmds[i][3]; } break; - case RFUCMD_CHILD_DISCONNECT: - if (Rfu.parent_child == MODE_PARENT) + case RFUCMD_DISCONNECT_PARENT: + if (gRfu.parentChild == MODE_PARENT) { - Rfu.bm_DisconnectSlot |= gRecvCmds[i][1]; - Rfu.unk_ce4 = gRecvCmds[i][2]; + gRfu.disconnectSlots |= gRecvCmds[i][1]; + gRfu.disconnectMode = gRecvCmds[i][2]; ClearSelectedLinkPlayerIds(gRecvCmds[i][1]); } break; + //case RFUCMD_BLENDER_SEND_KEYS: case RFUCMD_SEND_HELD_KEYS: gLinkPartnersHeldKeys[i] = gRecvCmds[i][1]; break; } - if (Rfu.parent_child == MODE_PARENT && Rfu.numBlocksReceived[i]) + if (gRfu.parentChild == MODE_PARENT && gRfu.numBlocksReceived[i]) { - if (Rfu.numBlocksReceived[i] == 4) + if (gRfu.numBlocksReceived[i] == 4) { - Rfu.blockReceived[i] = TRUE; - Rfu.numBlocksReceived[i] = 0; + gRfu.blockReceived[i] = TRUE; + gRfu.numBlocksReceived[i] = 0; } else - Rfu.numBlocksReceived[i]++; + gRfu.numBlocksReceived[i]++; } } } -static bool8 AreNoPlayersReceiving(void) +static bool8 AreAllPlayersReadyToReceive(void) { s32 i; - for (i = 0; i < 5; i++) + for (i = 0; i < MAX_RFU_PLAYERS; i++) { - if (Rfu.recvBlock[i].receiving != RFU_RECV_IDLE) + if (gRfu.recvBlock[i].receiving != RECV_STATE_READY) return FALSE; } return TRUE; @@ -1142,9 +1183,9 @@ static bool8 AreAllPlayersFinishedReceiving(void) { s32 i; - for (i = 0; i < Rfu.playerCount; i++) + for (i = 0; i < gRfu.playerCount; i++) { - if (Rfu.recvBlock[i].receiving != RFU_RECV_FINISHED || Rfu.blockReceived[i] != TRUE) + if (gRfu.recvBlock[i].receiving != RECV_STATE_FINISHED || gRfu.blockReceived[i] != TRUE) return FALSE; } return TRUE; @@ -1156,9 +1197,9 @@ static void ResetSendDataManager(struct RfuBlockSend *data) data->count = 0; data->payload = NULL; data->receivedFlags = 0; - data->sending = 0; + data->sending = FALSE; data->owner = 0; - data->receiving = RFU_RECV_IDLE; + data->receiving = RECV_STATE_READY; } u8 Rfu_GetBlockReceivedStatus(void) @@ -1166,12 +1207,10 @@ u8 Rfu_GetBlockReceivedStatus(void) u8 flags = 0; s32 i; - for (i = 0; i < 5; i++) + for (i = 0; i < MAX_RFU_PLAYERS; i++) { - if (Rfu.recvBlock[i].receiving == RFU_RECV_FINISHED && Rfu.blockReceived[i] == TRUE) - { + if (gRfu.recvBlock[i].receiving == RECV_STATE_FINISHED && gRfu.blockReceived[i] == TRUE) flags |= (1 << i); - } } return flags; } @@ -1186,36 +1225,35 @@ static void RfuPrepareSendBuffer(u16 command) switch (command) { case RFUCMD_SEND_BLOCK_INIT: - gSendCmd[1] = Rfu.sendBlock.count; - gSendCmd[2] = Rfu.sendBlock.owner + 0x80; + gSendCmd[1] = gRfu.sendBlock.count; + gSendCmd[2] = gRfu.sendBlock.owner + 0x80; break; case RFUCMD_SEND_BLOCK_REQ: - if (AreNoPlayersReceiving()) - gSendCmd[1] = Rfu.cmdA100_blockRequestType; + if (AreAllPlayersReadyToReceive()) + gSendCmd[1] = gRfu.blockRequestType; break; - case RFUCMD_PLAYERS_LIST: - case RFUCMD_PLAYERS_LIST_2: - tmp = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; - Rfu.playerCount = sNumSetBits[tmp] + 1; - gSendCmd[1] = Rfu.playerCount; - buff = (u8 *)(gSendCmd + 2); + case RFUCMD_SEND_PLAYER_IDS: + case RFUCMD_SEND_PLAYER_IDS_NEW: + tmp = gRfu.parentSlots ^ gRfu.disconnectSlots; + gRfu.playerCount = sPlayerBitsToCount[tmp] + 1; + gSendCmd[1] = gRfu.playerCount; + buff = (u8 *)&gSendCmd[2]; for (i = 0; i < RFU_CHILD_MAX; i++) - buff[i] = Rfu.linkPlayerIdx[i]; + buff[i] = gRfu.linkPlayerIdx[i]; break; case RFUCMD_READY_EXIT_STANDBY: case RFUCMD_READY_CLOSE_LINK: - gSendCmd[1] = Rfu.resendExitStandbyCount; + gSendCmd[1] = gRfu.resendExitStandbyCount; break; case RFUCMD_SEND_PACKET: - for (i = 0; i < 6; i++) - gSendCmd[1 + i] = Rfu.packet[i]; + for (i = 0; i < RFU_PACKET_SIZE; i++) + gSendCmd[1 + i] = gRfu.packet[i]; break; case RFUCMD_SEND_HELD_KEYS: gSendCmd[1] = gHeldKeyCodeToSend; break; - case RFUCMD_CHILD_DISCONNECT: - break; - case RFUCMD_PARENT_DISCONNECT: + case RFUCMD_DISCONNECT_PARENT: + case RFUCMD_DISCONNECT: break; } } @@ -1224,40 +1262,41 @@ void Rfu_SendPacket(void *data) { if (IsSendCmdComplete() && !RfuHasErrored()) { - memcpy(Rfu.packet, data, sizeof(Rfu.packet)); + memcpy(gRfu.packet, data, sizeof(gRfu.packet)); RfuPrepareSendBuffer(RFUCMD_SEND_PACKET); } } bool32 Rfu_InitBlockSend(const u8 *src, size_t size) { - bool8 sizeHasModulo; + bool8 round; AGB_ASSERT_EX(size<=252, ABSPATH("rfu.c"), 1793); - if (Rfu.RfuFunc != NULL) + + if (gRfu.callback != NULL) return FALSE; if (gSendCmd[0] != 0) return FALSE; - if (Rfu.sendBlock.sending != 0) + if (gRfu.sendBlock.sending) { sRfuDebug.blockSendTime++; return FALSE; } - sizeHasModulo = (size % 12) != 0; - Rfu.sendBlock.owner = GetMultiplayerId(); - Rfu.sendBlock.sending = 1; - Rfu.sendBlock.count = (size / 12) + sizeHasModulo; - Rfu.sendBlock.next = 0; - if (size > 0x100) // should never be reached - Rfu.sendBlock.payload = src; + round = (size % 12) != 0; + gRfu.sendBlock.owner = GetMultiplayerId(); + gRfu.sendBlock.sending = TRUE; + gRfu.sendBlock.count = (size / 12) + round; + gRfu.sendBlock.next = 0; + if (size > BLOCK_BUFFER_SIZE) + gRfu.sendBlock.payload = src; else { if (src != gBlockSendBuffer) memcpy(gBlockSendBuffer, src, size); - Rfu.sendBlock.payload = gBlockSendBuffer; + gRfu.sendBlock.payload = gBlockSendBuffer; } RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT); - Rfu.RfuFunc = HandleBlockSend; - Rfu.sendBlockInitDelay = 0; + gRfu.callback = HandleBlockSend; + gRfu.sendBlockInitDelay = 0; return TRUE; } @@ -1266,139 +1305,141 @@ static void HandleBlockSend(void) if (IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT); - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) { - if (++Rfu.sendBlockInitDelay > 2) - Rfu.RfuFunc = SendNextBlock; + if (++gRfu.sendBlockInitDelay > 2) + gRfu.callback = SendNextBlock; } else { - if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFUCMD_SEND_BLOCK_INIT) - Rfu.RfuFunc = SendNextBlock; + if ((gRecvCmds[GetMultiplayerId()][0] & RFUCMD_MASK) == RFUCMD_SEND_BLOCK_INIT) + gRfu.callback = SendNextBlock; } } } static void SendNextBlock(void) { s32 i; - const u8 *src = Rfu.sendBlock.payload; - gSendCmd[0] = RFUCMD_SEND_BLOCK_STEP | Rfu.sendBlock.next; - for (i = 0; i < 7; i++) - gSendCmd[i + 1] = (src[(i << 1) + Rfu.sendBlock.next * 12 + 1] << 8) | src[(i << 1) + Rfu.sendBlock.next * 12 + 0]; - Rfu.sendBlock.next++; - if (Rfu.sendBlock.count <= Rfu.sendBlock.next) + const u8 *src = gRfu.sendBlock.payload; + gSendCmd[0] = RFUCMD_SEND_BLOCK | gRfu.sendBlock.next; + for (i = 0; i < CMD_LENGTH - 1; i++) + gSendCmd[i + 1] = (src[(i << 1) + gRfu.sendBlock.next * 12 + 1] << 8) | src[(i << 1) + gRfu.sendBlock.next * 12 + 0]; + gRfu.sendBlock.next++; + if (gRfu.sendBlock.count <= gRfu.sendBlock.next) { - Rfu.sendBlock.sending = 0; - Rfu.RfuFunc = SendLastBlock; + gRfu.sendBlock.sending = FALSE; + gRfu.callback = SendLastBlock; } } static void SendLastBlock(void) { - const u8 *src = Rfu.sendBlock.payload; + const u8 *src = gRfu.sendBlock.payload; u8 mpId = GetMultiplayerId(); s32 i; - if (Rfu.parent_child == MODE_CHILD) + if (gRfu.parentChild == MODE_CHILD) { - gSendCmd[0] = RFUCMD_SEND_BLOCK_STEP | (Rfu.sendBlock.count - 1); - for (i = 0; i < 7; i++) - gSendCmd[i + 1] = (src[(i << 1) + (Rfu.sendBlock.count - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.sendBlock.count - 1) * 12 + 0]; - if ((u8)gRecvCmds[mpId][0] == Rfu.sendBlock.count - 1) + gSendCmd[0] = RFUCMD_SEND_BLOCK | (gRfu.sendBlock.count - 1); + for (i = 0; i < CMD_LENGTH - 1; i++) + gSendCmd[i + 1] = (src[(i << 1) + (gRfu.sendBlock.count - 1) * 12 + 1] << 8) | src[(i << 1) + (gRfu.sendBlock.count - 1) * 12 + 0]; + if ((u8)gRecvCmds[mpId][0] == gRfu.sendBlock.count - 1) { - if (Rfu.recvBlock[mpId].receivedFlags != sAllBlocksReceived[Rfu.recvBlock[mpId].count]) + if (gRfu.recvBlock[mpId].receivedFlags != sAllBlocksReceived[gRfu.recvBlock[mpId].count]) { - HandleSendFailure(mpId, Rfu.recvBlock[mpId].receivedFlags); + HandleSendFailure(mpId, gRfu.recvBlock[mpId].receivedFlags); sRfuDebug.blockSendFailures++; } else - Rfu.RfuFunc = NULL; + gRfu.callback = NULL; } } else - Rfu.RfuFunc = NULL; + gRfu.callback = NULL; } bool8 Rfu_SendBlockRequest(u8 blockRequestType) { - Rfu.cmdA100_blockRequestType = blockRequestType; + gRfu.blockRequestType = blockRequestType; RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ); return TRUE; } -static void OnDisconnect_PowerDownRfu(void) +static void RfuShutdownAfterDisconnect(void) { rfu_clearAllSlot(); rfu_LMAN_powerDownRFU(); gReceivedRemoteLinkPlayers = FALSE; - Rfu.isShuttingDown = TRUE; - Rfu.RfuFunc = NULL; + gRfu.isShuttingDown = TRUE; + gRfu.callback = NULL; } static void DisconnectRfu(void) { rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag); rfu_waitREQComplete(); - OnDisconnect_PowerDownRfu(); + RfuShutdownAfterDisconnect(); } static void TryDisconnectRfu(void) { - if (Rfu.parent_child == MODE_CHILD) + if (gRfu.parentChild == MODE_CHILD) { rfu_LMAN_requestChangeAgbClockMaster(); - Rfu.unk_ce4 = 2; + gRfu.disconnectMode = RFU_DISCONNECT_NORMAL; } else - Rfu.RfuFunc = DisconnectRfu; + gRfu.callback = DisconnectRfu; } void LinkRfu_FatalError(void) { rfu_LMAN_requestChangeAgbClockMaster(); - Rfu.unk_ce4 = 1; - Rfu.bm_DisconnectSlot = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + gRfu.disconnectMode = RFU_DISCONNECT_ERROR; + gRfu.disconnectSlots = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; } // RFU equivalent of LinkCB_WaitCloseLink static void WaitAllReadyToCloseLink(void) { s32 i; - u8 playerCount = Rfu.playerCount; + u8 playerCount = gRfu.playerCount; s32 count = 0; + // Wait for all players to be ready for (i = 0; i < MAX_RFU_PLAYERS; i++) { - if (Rfu.readyCloseLink[i]) + if (gRfu.readyCloseLink[i]) count++; } if (count == playerCount) { + // All ready, close link gBattleTypeFlags &= ~(BATTLE_TYPE_LINK_IN_BATTLE | 0xFFFF0000); - if (Rfu.parent_child == MODE_CHILD) + if (gRfu.parentChild == MODE_CHILD) { - Rfu.errorState = 3; + gRfu.errorState = RFU_ERROR_STATE_DISCONNECTING; TryDisconnectRfu(); } else - Rfu.RfuFunc = TryDisconnectRfu; + gRfu.callback = TryDisconnectRfu; } } static void SendReadyCloseLink(void) { - if (IsSendCmdComplete() && !Rfu.foundNewLeaderMaybe) + if (IsSendCmdComplete() && !gRfu.playerExchangeActive) { RfuPrepareSendBuffer(RFUCMD_READY_CLOSE_LINK); - Rfu.RfuFunc = WaitAllReadyToCloseLink; + gRfu.callback = WaitAllReadyToCloseLink; } } static void Task_TryReadyCloseLink(u8 taskId) { - if (Rfu.RfuFunc == NULL) + if (gRfu.callback == NULL) { - Rfu.linkClosing = TRUE; - Rfu.RfuFunc = SendReadyCloseLink; + gRfu.stopNewConnections = TRUE; + gRfu.callback = SendReadyCloseLink; DestroyTask(taskId); } } @@ -1416,34 +1457,34 @@ static void SendReadyExitStandbyUntilAllReady(void) if (GetMultiplayerId() != 0) // child { - if (Rfu.recvQueue.count == 0 && Rfu.resendExitStandbyTimer > 60) + if (gRfu.recvQueue.count == 0 && gRfu.resendExitStandbyTimer > 60) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); - Rfu.resendExitStandbyTimer = 0; + gRfu.resendExitStandbyTimer = 0; } } playerCount = GetLinkPlayerCount(); for (i = 0; i < playerCount; i++) { - if (Rfu.readyExitStandby[i] == 0) + if (!gRfu.readyExitStandby[i]) break; } if (i == playerCount) { for (i = 0; i < MAX_RFU_PLAYERS; i++) - Rfu.readyExitStandby[i] = 0; - Rfu.resendExitStandbyCount++; - Rfu.RfuFunc = NULL; + gRfu.readyExitStandby[i] = FALSE; + gRfu.resendExitStandbyCount++; + gRfu.callback = NULL; } - Rfu.resendExitStandbyTimer++; + gRfu.resendExitStandbyTimer++; } static void LinkLeaderReadyToExitStandby(void) { - if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) + if (gRfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); - Rfu.RfuFunc = SendReadyExitStandbyUntilAllReady; + gRfu.callback = SendReadyExitStandbyUntilAllReady; } } @@ -1453,28 +1494,30 @@ static void Rfu_LinkStandby(void) u8 i; u8 playerCount; - if (GetMultiplayerId() != 0) // child + if (GetMultiplayerId() != 0) { - if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) + // Not link leader, send exit standby when ready + if (gRfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); - Rfu.RfuFunc = SendReadyExitStandbyUntilAllReady; + gRfu.callback = SendReadyExitStandbyUntilAllReady; } } - else // parent + else { + // Link leader, wait for all members to send exit ready playerCount = GetLinkPlayerCount(); for (i = 1; i < playerCount; i++) { - if (Rfu.readyExitStandby[i] == 0) + if (!gRfu.readyExitStandby[i]) break; } if (i == playerCount) { - if (Rfu.recvQueue.count == 0 && IsSendCmdComplete()) + if (gRfu.recvQueue.count == 0 && IsSendCmdComplete()) { RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY); - Rfu.RfuFunc = LinkLeaderReadyToExitStandby; + gRfu.callback = LinkLeaderReadyToExitStandby; } } } @@ -1482,10 +1525,10 @@ static void Rfu_LinkStandby(void) void Rfu_SetLinkStandbyCallback(void) { - if (Rfu.RfuFunc == NULL) + if (gRfu.callback == NULL) { - Rfu.RfuFunc = Rfu_LinkStandby; - Rfu.resendExitStandbyTimer = 0; + gRfu.callback = Rfu_LinkStandby; + gRfu.resendExitStandbyTimer = 0; } } @@ -1494,13 +1537,13 @@ bool32 IsRfuSerialNumberValid(u32 serialNo) s32 i; for (i = 0; sAcceptedSerialNos[i] != serialNo; i++) { - if (sAcceptedSerialNos[i] == 0xFFFF) + if (sAcceptedSerialNos[i] == RFU_SERIAL_END) return FALSE; } return TRUE; } -u8 ToggleLMANlinkRecovery(bool32 enable) +u8 Rfu_SetLinkRecovery(bool32 enable) { if (!enable) return rfu_LMAN_setLinkRecovery(FALSE, 0); @@ -1508,121 +1551,129 @@ u8 ToggleLMANlinkRecovery(bool32 enable) return 0; } -void Rfu_UnionRoomChat_StopLinkManager(void) +void Rfu_StopPartnerSearch(void) { - Rfu.linkClosing = TRUE; + gRfu.stopNewConnections = TRUE; rfu_LMAN_stopManager(FALSE); } -u8 LinkRfu_GetMultiplayerId(void) +u8 Rfu_GetMultiplayerId(void) { - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) return 0; - return Rfu.multiplayerId; + return gRfu.multiplayerId; } -u8 GetRfuPlayerCount(void) +u8 Rfu_GetLinkPlayerCount(void) { - return Rfu.playerCount; + return gRfu.playerCount; } bool8 IsLinkRfuTaskFinished(void) { - return Rfu.RfuFunc != NULL ? FALSE : TRUE; + return gRfu.callback != NULL ? FALSE : TRUE; } static void CallRfuFunc(void) { - if (Rfu.RfuFunc != NULL) - Rfu.RfuFunc(); + if (gRfu.callback != NULL) + gRfu.callback(); } static bool8 CheckForLeavingGroupMembers(void) { s32 i; - bool8 retval = FALSE; + bool8 memberLeft = FALSE; for (i = 0; i < RFU_CHILD_MAX; i++) { - if (Rfu.partnerSendStatuses[i] < RFU_STATUS_JOIN_GROUP_OK - || Rfu.partnerSendStatuses[i] > RFU_STATUS_JOIN_GROUP_NO) + if (gRfu.partnerSendStatuses[i] < RFU_STATUS_JOIN_GROUP_OK + || gRfu.partnerSendStatuses[i] > RFU_STATUS_JOIN_GROUP_NO) { - if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) + if (gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS + || gRfuSlotStatusNI[i]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) { - if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_LEAVE_GROUP_NOTICE) + if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_LEAVE_GROUP_NOTICE) { - Rfu.partnerSendStatuses[i] = RFU_STATUS_LEAVE_GROUP; - Rfu.partnerRecvStatuses[i] = RFU_STATUS_10; + gRfu.partnerSendStatuses[i] = RFU_STATUS_LEAVE_GROUP; + gRfu.partnerRecvStatuses[i] = RFU_STATUS_CHILD_LEAVE_READY; rfu_clearSlot(TYPE_NI_RECV, i); - rfu_NI_setSendData(1 << i, 8, &Rfu.partnerSendStatuses[i], 1); - retval = TRUE; + rfu_NI_setSendData(1 << i, 8, &gRfu.partnerSendStatuses[i], 1); + memberLeft = TRUE; } } - else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) + else if (gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_FAILED) { rfu_clearSlot(TYPE_NI_RECV, i); } } } - return retval; + return memberLeft; } -bool32 sub_80FA5D4(void) +bool32 RfuTryDisconnectLeavingChildren(void) { - u8 flags = 0; + u8 childrenLeaving = 0; s32 i; + + // Check all children, get those waiting to be disconnected for (i = 0; i < RFU_CHILD_MAX; i++) { - if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_11) + if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE) { - flags |= (1 << i); - Rfu.partnerRecvStatuses[i] = RFU_STATUS_OK; + childrenLeaving |= (1 << i); + gRfu.partnerRecvStatuses[i] = RFU_STATUS_OK; } } - if (flags) + + // Disconnect any leaving children + if (childrenLeaving) { - rfu_REQ_disconnect(flags); + rfu_REQ_disconnect(childrenLeaving); rfu_waitREQComplete(); } + + // Return true if any children have left or are still waiting to leave for (i = 0; i < RFU_CHILD_MAX; i++) { - if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_10 || Rfu.partnerRecvStatuses[i] == RFU_STATUS_11) + if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE_READY + || gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE) return TRUE; } return FALSE; } -bool32 CheckTrainerHasLeftByIdAndName(u16 trainerId, const u8 *trainerName) +bool32 HasTrainerLeftPartnersList(u16 trainerId, const u8 *name) { - u8 r1 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); - if (r1 == 0xFF) + u8 idx = GetPartnerIndexByNameAndTrainerID(name, trainerId); + if (idx == 0xFF) return TRUE; - if (Rfu.partnerSendStatuses[r1] == RFU_STATUS_LEAVE_GROUP) + if (gRfu.partnerSendStatuses[idx] == RFU_STATUS_LEAVE_GROUP) return TRUE; return FALSE; } -void SendByteToPartnerByIdAndName(u8 value, u16 trainerId, const u8 *trainerName) +void SendRfuStatusToPartner(u8 status, u16 trainerId, const u8 *name) { - u8 slotNo = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); - Rfu.partnerSendStatuses[slotNo] = value; - rfu_clearSlot(TYPE_NI_SEND, slotNo); - rfu_NI_setSendData(1 << slotNo, 8, Rfu.partnerSendStatuses + slotNo, 1); + u8 idx = GetPartnerIndexByNameAndTrainerID(name, trainerId); + gRfu.partnerSendStatuses[idx] = status; + rfu_clearSlot(TYPE_NI_SEND, idx); + rfu_NI_setSendData(1 << idx, 8, &gRfu.partnerSendStatuses[idx], 1); } void SendLeaveGroupNotice(void) { - Rfu.sendStatus = RFU_STATUS_LEAVE_GROUP_NOTICE; - rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot); - rfu_NI_setSendData(1 << Rfu.child_slot, 8, &Rfu.sendStatus, 1); + gRfu.sendStatus = RFU_STATUS_LEAVE_GROUP_NOTICE; + rfu_clearSlot(TYPE_NI_SEND, gRfu.childSlot); + rfu_NI_setSendData(1 << gRfu.childSlot, 8, &gRfu.sendStatus, 1); } -u32 WaitSendByteToPartnerByIdAndName(u16 trainerId, const u8 *trainerName) +u32 WaitSendRfuStatusToPartner(u16 trainerId, const u8 *name) { - u8 r0 = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); - if (r0 == 0xFF) + u8 idx = GetPartnerIndexByNameAndTrainerID(name, trainerId); + if (idx == 0xFF) return 2; - if (gRfuSlotStatusNI[r0]->send.state == SLOT_STATE_READY) + if (gRfuSlotStatusNI[idx]->send.state == SLOT_STATE_READY) return 1; return 0; } @@ -1634,114 +1685,119 @@ static void UpdateChildStatuses(void) CheckForLeavingGroupMembers(); for (i = 0; i < RFU_CHILD_MAX; i++) { - if (gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_FAILED) + if (gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_SUCCESS + || gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_FAILED) { - if (Rfu.partnerRecvStatuses[i] == RFU_STATUS_10) - Rfu.partnerRecvStatuses[i] = RFU_STATUS_11; + if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE_READY) + gRfu.partnerRecvStatuses[i] = RFU_STATUS_CHILD_LEAVE; rfu_clearSlot(TYPE_NI_SEND, i); } } } -static s32 GetRfuRecvStatus(void) +static s32 GetJoinGroupStatus(void) { - s32 retval = RFU_STATUS_OK; - if (Rfu.sendStatus == RFU_STATUS_LEAVE_GROUP_NOTICE) + s32 status = RFU_STATUS_OK; + if (gRfu.sendStatus == RFU_STATUS_LEAVE_GROUP_NOTICE) { - if (gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->send.state == SLOT_STATE_SEND_FAILED) - rfu_clearSlot(TYPE_NI_SEND, Rfu.child_slot); + if (gRfuSlotStatusNI[gRfu.childSlot]->send.state == SLOT_STATE_SEND_SUCCESS + || gRfuSlotStatusNI[gRfu.childSlot]->send.state == SLOT_STATE_SEND_FAILED) + rfu_clearSlot(TYPE_NI_SEND, gRfu.childSlot); } - if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS || gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) + if (gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_SUCCESS + || gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN) { - rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot); - RfuSetStatus(Rfu.recvStatus, 0); - retval = Rfu.recvStatus; + rfu_clearSlot(TYPE_NI_RECV, gRfu.childSlot); + RfuSetStatus(gRfu.recvStatus, 0); + status = gRfu.recvStatus; } - else if (gRfuSlotStatusNI[Rfu.child_slot]->recv.state == SLOT_STATE_RECV_FAILED) + else if (gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_FAILED) { - rfu_clearSlot(TYPE_NI_RECV, Rfu.child_slot); - retval = RFU_STATUS_JOIN_GROUP_NO; + rfu_clearSlot(TYPE_NI_RECV, gRfu.childSlot); + status = RFU_STATUS_JOIN_GROUP_NO; } - return retval; + return status; } -static void sub_80FA834(u8 taskId) +#define tState data[0] + +static void Task_PlayerExchange(u8 taskId) { s32 i; - if (Rfu.status == RFU_STATUS_FATAL_ERROR || Rfu.status == RFU_STATUS_CONNECTION_ERROR) + if (gRfu.status == RFU_STATUS_FATAL_ERROR || gRfu.status == RFU_STATUS_CONNECTION_ERROR) { - Rfu.foundNewLeaderMaybe = FALSE; + gRfu.playerExchangeActive = FALSE; DestroyTask(taskId); } - switch (gTasks[taskId].data[0]) + switch (gTasks[taskId].tState) { case 0: - if (AreNoPlayersReceiving()) + if (AreAllPlayersReadyToReceive()) { ResetBlockReceivedFlags(); LocalLinkPlayerToBlock(); - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; } break; case 1: - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) { if (gReceivedRemoteLinkPlayers) - RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST_2); + RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS_NEW); else - RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST); - gTasks[taskId].data[0] = 101; + RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS); + gTasks[taskId].tState = 101; } else - gTasks[taskId].data[0] = 2; + gTasks[taskId].tState = 2; break; case 101: if (IsSendCmdComplete()) - gTasks[taskId].data[0] = 2; + gTasks[taskId].tState = 2; break; case 2: - if (Rfu.playerCount) - gTasks[taskId].data[0]++; + if (gRfu.playerCount) + gTasks[taskId].tState++; break; case 3: - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.parentChild == MODE_PARENT) { - if (AreNoPlayersReceiving()) + if (AreAllPlayersReadyToReceive()) { - Rfu.cmdA100_blockRequestType = BLOCK_REQ_SIZE_NONE; + gRfu.blockRequestType = BLOCK_REQ_SIZE_NONE; RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ); - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; } } else - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 4: if (AreAllPlayersFinishedReceiving()) - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 5: - for (i = 0; i < Rfu.playerCount; i++) + for (i = 0; i < gRfu.playerCount; i++) { LinkPlayerFromBlock(i); Rfu_ResetBlockReceivedFlag(i); } - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 6: DestroyTask(taskId); gReceivedRemoteLinkPlayers = TRUE; - Rfu.foundNewLeaderMaybe = FALSE; + gRfu.playerExchangeActive = FALSE; rfu_LMAN_setLinkRecovery(1, 600); - if (Rfu.unionRoomChatters) + if (gRfu.newChildQueue) { for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((Rfu.unionRoomChatters >> i) & 1) + if ((gRfu.newChildQueue >> i) & 1) { - Rfu.bmChatLeaderMaybe = 1 << i; - Rfu.unionRoomChatters ^= (1 << i); + gRfu.nextChildBits = 1 << i; + gRfu.newChildQueue ^= (1 << i); } } } @@ -1749,33 +1805,59 @@ static void sub_80FA834(u8 taskId) } } -static void ClearSelectedLinkPlayerIds(u16 disconnectMask) +static void ClearSelectedLinkPlayerIds(u16 selected) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((disconnectMask >> i) & 1) - Rfu.linkPlayerIdx[i] = 0; + if ((selected >> i) & 1) + gRfu.linkPlayerIdx[i] = 0; } } -static void ReceiveRfuLinkPlayers(const struct SioInfo *chunk) +static void ReceiveRfuLinkPlayers(const struct SioInfo *sioInfo) { s32 i; - Rfu.playerCount = chunk->playerCount; + gRfu.playerCount = sioInfo->playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - Rfu.linkPlayerIdx[i] = chunk->linkPlayerIdx[i]; + gRfu.linkPlayerIdx[i] = sioInfo->linkPlayerIdx[i]; for (i = 0; i < MAX_RFU_PLAYERS; i++) { - gLinkPlayers[i] = chunk->linkPlayers[i]; + gLinkPlayers[i] = sioInfo->linkPlayers[i]; ConvertLinkPlayerName(gLinkPlayers + i); } } +// Could be relocated to top of file, but would also require relocating assert strings +static const char sASCII_PokemonSioInfo[] = "PokemonSioInfo"; +static const u8 sText_Akito[] = _("　あきと"); // Presumably "Akito Mori", one of Game Freak's programmers +static const char sASCII_LinkLossDisconnect[] = "LINK LOSS DISCONNECT!"; +static const char sASCII_LinkLossRecoveryNow[] = "LINK LOSS RECOVERY NOW"; +ALIGNED(4) static const char sASCII_30Spaces[] = {" "}; +static const char sASCII_15Spaces[] = {" "}; +static const char sASCII_8Spaces[] = {" "}; +ALIGNED(4) static const char sASCII_Space[] = {" "}; +static const char sASCII_Asterisk[] = {"*"}; +static const char sASCII_NowSlot[] = "NOWSLOT"; + +static const char sASCII_ClockCmds[][12] = { + " ", + "CLOCK DRIFT", + "BUSY SEND ", + "CMD REJECT ", + "CLOCK SLAVE" +}; + +static const char sASCII_ChildParentSearch[][8] = { + "CHILD ", + "PARENT", + "SEARCH" +}; + static void ValidateAndReceivePokemonSioInfo(void *recvBuffer) { - if (strcmp("PokemonSioInfo", recvBuffer) == 0) + if (strcmp(sASCII_PokemonSioInfo, recvBuffer) == 0) { ReceiveRfuLinkPlayers(recvBuffer); CpuFill16(0, recvBuffer, sizeof(struct SioInfo)); @@ -1783,75 +1865,76 @@ static void ValidateAndReceivePokemonSioInfo(void *recvBuffer) } } -static void Task_ExchangeLinkPlayers(u8 taskId) +// Equivalent to Task_PlayerExchange, but for when new children arrive after the first exchange +static void Task_PlayerExchangeUpdate(u8 taskId) { s32 i; - struct LinkPlayerBlock *r2; - struct SioInfo *r5; - u8 r4 = Rfu.linkPlayerIdx[gUnknown_843EC38[Rfu.unk_ce9]]; - if (Rfu.status == 1 || Rfu.status == 2) + struct LinkPlayerBlock *playerBlock; + struct SioInfo *sio; + u8 playerId = gRfu.linkPlayerIdx[sSlotToLinkPlayerTableId[gRfu.incomingChild]]; + if (gRfu.status == RFU_STATUS_FATAL_ERROR || gRfu.status == RFU_STATUS_CONNECTION_ERROR) { - Rfu.foundNewLeaderMaybe = FALSE; + gRfu.playerExchangeActive = FALSE; DestroyTask(taskId); } - switch (gTasks[taskId].data[0]) + switch (gTasks[taskId].tState) { case 0: if (IsSendCmdComplete()) { - ResetBlockReceivedFlag(r4); - RfuPrepareSendBuffer(RFUCMD_PLAYERS_LIST_2); - gTasks[taskId].data[0]++; + ResetBlockReceivedFlag(playerId); + RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS_NEW); + gTasks[taskId].tState++; } break; case 1: if (IsSendCmdComplete()) - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 2: - if ((GetBlockReceivedStatus() >> r4) & 1) + if ((GetBlockReceivedStatus() >> playerId) & 1) { - ResetBlockReceivedFlag(r4); - r2 = (struct LinkPlayerBlock *)gBlockRecvBuffer[r4]; - gLinkPlayers[r4] = r2->linkPlayer; - ConvertLinkPlayerName(gLinkPlayers + r4); - gTasks[taskId].data[0]++; + ResetBlockReceivedFlag(playerId); + playerBlock = (struct LinkPlayerBlock *)gBlockRecvBuffer[playerId]; + gLinkPlayers[playerId] = playerBlock->linkPlayer; + ConvertLinkPlayerName(&gLinkPlayers[playerId]); + gTasks[taskId].tState++; } break; case 3: // Prepare send block - r5 = (struct SioInfo *)gBlockSendBuffer; - memcpy(r5->magic, "PokemonSioInfo", sizeof("PokemonSioInfo")); - r5->playerCount = Rfu.playerCount; + sio = (struct SioInfo *)gBlockSendBuffer; + memcpy(sio->magic, sASCII_PokemonSioInfo, sizeof sASCII_PokemonSioInfo); + sio->playerCount = gRfu.playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i]; - memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); - gTasks[taskId].data[0]++; + sio->linkPlayerIdx[i] = gRfu.linkPlayerIdx[i]; + memcpy(sio->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); + gTasks[taskId].tState++; // fallthrough case 4: - r5 = (struct SioInfo *)gBlockSendBuffer; - r5->playerCount = Rfu.playerCount; + sio = (struct SioInfo *)gBlockSendBuffer; + sio->playerCount = gRfu.playerCount; for (i = 0; i < RFU_CHILD_MAX; i++) - r5->linkPlayerIdx[i] = Rfu.linkPlayerIdx[i]; - memcpy(r5->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); + sio->linkPlayerIdx[i] = gRfu.linkPlayerIdx[i]; + memcpy(sio->linkPlayers, gLinkPlayers, sizeof gLinkPlayers); if (SendBlock(0, gBlockSendBuffer, 0xa0)) - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 5: if (IsLinkTaskFinished() && GetBlockReceivedStatus() & 1) { CpuFill16(0, gBlockRecvBuffer, sizeof(struct SioInfo)); ResetBlockReceivedFlag(0); - Rfu.foundNewLeaderMaybe = FALSE; - if (Rfu.unionRoomChatters) + gRfu.playerExchangeActive = FALSE; + if (gRfu.newChildQueue) { for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((Rfu.unionRoomChatters >> i) & 1) + if ((gRfu.newChildQueue >> i) & 1) { - Rfu.bmChatLeaderMaybe = 1 << i; - Rfu.unionRoomChatters ^= (1 << i); - Rfu.foundNewLeaderMaybe = TRUE; + gRfu.nextChildBits = 1 << i; + gRfu.newChildQueue ^= (1 << i); + gRfu.playerExchangeActive = TRUE; break; } } @@ -1862,23 +1945,24 @@ static void Task_ExchangeLinkPlayers(u8 taskId) } } -static void sub_80FACF0(u8 taskId) +// Equivalent to Task_PlayerExchange but for chatting with a Union Room partner +static void Task_PlayerExchangeChat(u8 taskId) { - if (Rfu.status == RFU_STATUS_FATAL_ERROR || Rfu.status == RFU_STATUS_CONNECTION_ERROR) + if (gRfu.status == RFU_STATUS_FATAL_ERROR || gRfu.status == RFU_STATUS_CONNECTION_ERROR) DestroyTask(taskId); - switch (gTasks[taskId].data[0]) + switch (gTasks[taskId].tState) { case 0: - if (Rfu.playerCount != 0) + if (gRfu.playerCount != 0) { LocalLinkPlayerToBlock(); SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock)); - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; } break; case 1: if (IsLinkTaskFinished()) - gTasks[taskId].data[0]++; + gTasks[taskId].tState++; break; case 2: if (GetBlockReceivedStatus() & 1) @@ -1894,31 +1978,31 @@ static void sub_80FACF0(u8 taskId) static void RfuCheckErrorStatus(void) { - if (Rfu.errorState == 1 && lman.childClockSlave_flag == 0) + if (gRfu.errorState == RFU_ERROR_STATE_OCCURRED && lman.childClockSlave_flag == 0) { - if (gMain.callback2 == c2_mystery_gift_e_reader_run) + if (gMain.callback2 == CB2_MysteryGiftEReader) gWirelessCommType = 2; SetMainCallback2(CB2_LinkError); gMain.savedCallback = CB2_LinkError; SetLinkErrorFromRfu( - (Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], - Rfu.recvQueue.count, - Rfu.sendQueue.count, + (gRfu.errorInfo << 16) | (gRfu.errorParams[0] << 8) | gRfu.errorParams[1], + gRfu.recvQueue.count, + gRfu.sendQueue.count, RfuGetStatus() == RFU_STATUS_CONNECTION_ERROR ); - Rfu.errorState = 2; + gRfu.errorState = RFU_ERROR_STATE_PROCESSED; CloseLink(); } - else if (Rfu.sendQueue.full == TRUE || Rfu.recvQueue.full == TRUE) + else if (gRfu.sendQueue.full == TRUE || gRfu.recvQueue.full == TRUE) { if (lman.childClockSlave_flag) rfu_LMAN_requestChangeAgbClockMaster(); - RfuSetStatus(RFU_STATUS_FATAL_ERROR, 0x7000); - GetLinkmanErrorParams(0x7000); + RfuSetStatus(RFU_STATUS_FATAL_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); + RfuSetErrorParams(F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); } } -static void rfu_REQ_recvData_then_sendData(void) +static void RfuMain1_UnionRoom(void) { if (lman.parent_child == MODE_PARENT) { @@ -1928,180 +2012,183 @@ static void rfu_REQ_recvData_then_sendData(void) } } -bool32 LinkRfuMain1(void) +// Rfu equivalent of LinkMain1 +bool32 RfuMain1(void) { bool32 retval = FALSE; - Rfu.parentId = 0; + gRfu.parentId = 0; rfu_LMAN_manager_entity(Random()); - if (!Rfu.isShuttingDown) + if (!gRfu.isShuttingDown) { - switch (Rfu.parent_child) + switch (gRfu.parentChild) { case MODE_PARENT: - sub_80F911C(); + RfuMain1_Parent(); break; case MODE_CHILD: - retval = RfuProcessEnqueuedRecvBlock(); + retval = RfuMain1_Child(); break; case MODE_P_C_SWITCH: - rfu_REQ_recvData_then_sendData(); + RfuMain1_UnionRoom(); break; } } return retval; } -bool32 LinkRfuMain2(void) +// Rfu equivalent of LinkMain2 +bool32 RfuMain2(void) { bool32 retval = FALSE; - if (!Rfu.isShuttingDown) + if (!gRfu.isShuttingDown) { - if (Rfu.parent_child == MODE_PARENT) - retval = sub_80F9204(); + if (gRfu.parentChild == MODE_PARENT) + retval = RfuMain2_Parent(); RfuCheckErrorStatus(); } return retval; } -static void CopyPlayerNameToUnameBuffer(void) +static void SetHostRfuUsername(void) { StringCopy(gHostRfuUsername, gSaveBlock2Ptr->playerName); } -void ClearAndInitHostRFUtgtGname(void) +void ResetHostRfuGameData(void) { memset(&gHostRfuGameData, 0, RFU_GAME_NAME_LENGTH); InitHostRFUtgtGname(&gHostRfuGameData, ACTIVITY_NONE, FALSE, 0); } -void SetHostRFUtgtGname(u8 activity, u32 child_sprite_genders, u32 started) +void SetHostRfuGameData(u8 activity, u32 partnerInfo, u32 startedActivity) { - InitHostRFUtgtGname(&gHostRfuGameData, activity, started, child_sprite_genders); + InitHostRFUtgtGname(&gHostRfuGameData, activity, startedActivity, partnerInfo); } -void SetGnameBufferWonderFlags(bool32 hasNews, bool32 hasCard) +void SetHostRfuWonderFlags(bool32 hasNews, bool32 hasCard) { - gHostRfuGameData.unk_00.hasNews = hasNews; - gHostRfuGameData.unk_00.hasCard = hasCard; + gHostRfuGameData.compatibility.hasNews = hasNews; + gHostRfuGameData.compatibility.hasCard = hasCard; } -void RfuUpdatePlayerGnameStateAndSend(u32 type, u32 species, u32 level) +void SetTradeBoardRegisteredMonInfo(u32 type, u32 species, u32 level) { - gHostRfuGameData.type = type; - gHostRfuGameData.species = species; - gHostRfuGameData.level = level; + gHostRfuGameData.tradeType = type; + gHostRfuGameData.tradeSpecies = species; + gHostRfuGameData.tradeLevel = level; } -void UpdateGameData_GroupLockedIn(bool8 started) +void UpdateGameData_GroupLockedIn(bool8 startedActivity) { - gHostRfuGameData.started = started; - rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRfuGameData, gHostRfuUsername); + gHostRfuGameData.startedActivity = startedActivity; + rfu_REQ_configGameData(0, RFU_SERIAL_GAME, (void *)&gHostRfuGameData, gHostRfuUsername); } -void UpdateGameDataWithActivitySpriteGendersFlag(u8 activity, u32 child_sprite_genders, u32 started) +void UpdateGameData_SetActivity(u8 activity, u32 partnerInfo, u32 startedActivity) { - if (activity) - SetHostRFUtgtGname(activity, child_sprite_genders, started); - rfu_REQ_configGameData(0, 0x0002, (void *)&gHostRfuGameData, gHostRfuUsername); + if (activity != ACTIVITY_NONE) + SetHostRfuGameData(activity, partnerInfo, startedActivity); + rfu_REQ_configGameData(0, RFU_SERIAL_GAME, (void *)&gHostRfuGameData, gHostRfuUsername); } -void sub_80FB030(u32 linkPlayerCount) +void SetUnionRoomChatPlayerData(u32 numPlayers) { s32 i; u32 numConnectedChildren; - u32 child_sprite_genders; - s32 bm_child_slots; + u32 partnerInfo; + s32 slots; - if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) + if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { numConnectedChildren = 0; - child_sprite_genders = 0; - bm_child_slots = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot; + partnerInfo = 0; + slots = gRfu.parentSlots ^ gRfu.disconnectSlots; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((bm_child_slots >> i) & 1) + if ((slots >> i) & 1) { - // The 0x80 prevents this element from being incorrectly read as a 0. - child_sprite_genders |= (( - 0x80 | ((gLinkPlayers[Rfu.linkPlayerIdx[i]].gender & 1) << 3) | (gLinkPlayers[Rfu.linkPlayerIdx[i]].trainerId & 7) - ) << (numConnectedChildren << 3)); + // Only trainerId is shifted by the number of children, so the active flag and gender + // are only ever set for the first child + partnerInfo |= ((PINFO_ACTIVE_FLAG + | ((gLinkPlayers[gRfu.linkPlayerIdx[i]].gender & 1) << PINFO_GENDER_SHIFT) + | (gLinkPlayers[gRfu.linkPlayerIdx[i]].trainerId & PINFO_TID_MASK)) << (numConnectedChildren * 8)); numConnectedChildren++; - if (numConnectedChildren == linkPlayerCount - 1) + if (numConnectedChildren == numPlayers - 1) break; } } - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, child_sprite_genders, 0); + UpdateGameData_SetActivity(ACTIVITY_CHAT | IN_UNION_ROOM, partnerInfo, FALSE); } } -static void GetLinkmanErrorParams(u32 msg) +static void RfuSetErrorParams(u32 errorInfo) { - if (Rfu.errorState == 0) + if (gRfu.errorState == RFU_ERROR_STATE_NONE) { - Rfu.linkman_param[0] = lman.param[0]; - Rfu.linkman_param[1] = lman.param[1]; - Rfu.linkman_msg = msg; - Rfu.errorState = 1; + gRfu.errorParams[0] = lman.param[0]; + gRfu.errorParams[1] = lman.param[1]; + gRfu.errorInfo = errorInfo; + gRfu.errorState = RFU_ERROR_STATE_OCCURRED; } } static void ResetErrorState(void) { - Rfu.errorState = 0; + gRfu.errorState = RFU_ERROR_STATE_NONE; } -void sub_80FB128(bool32 a0) +void RfuSetIgnoreError(bool32 enable) { - if (!a0) - Rfu.errorState = 0; + if (!enable) + gRfu.errorState = RFU_ERROR_STATE_NONE; else - Rfu.errorState = 4; + gRfu.errorState = RFU_ERROR_STATE_IGNORE; } -static void sub_80FB154(void) +static void DisconnectNewChild(void) { - sub_80FBE20(lman.acceptSlot_flag, 1); - Rfu.RfuFunc = NULL; + SendDisconnectCommand(lman.acceptSlot_flag, RFU_DISCONNECT_ERROR); + gRfu.callback = NULL; } -static void sub_80FB174(void) +static void StartDisconnectNewChild(void) { - Rfu.RfuFunc = sub_80FB154; + gRfu.callback = DisconnectNewChild; } -static void LmanCallback_Parent2(u8 msg, u8 param_count) +static void LinkManagerCB_Parent(u8 msg, u8 param_count) { u8 i; - u8 bmDisconnectFlag = 0; + u8 disconnectFlag = 0; switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: - Rfu.state = 2; + gRfu.state = RFUSTATE_PARENT_CONNECT; break; case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: break; case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: - sub_80FB564(lman.param[0]); + ParentResetChildRecvMetadata(lman.param[0]); for (i = 0; i < RFU_CHILD_MAX; i++) { if ((lman.param[0] >> i) & 1) { struct RfuGameData *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; - if (structPtr->activity == GetHostRFUtgtGname()->activity) + if (structPtr->activity == GetHostRfuGameData()->activity) { - Rfu.partnerSendStatuses[i] = RFU_STATUS_OK; - Rfu.partnerRecvStatuses[i] = RFU_STATUS_OK; - rfu_setRecvBuffer(TYPE_NI, i, Rfu.partnerRecvStatuses + i, 1); + gRfu.partnerSendStatuses[i] = RFU_STATUS_OK; + gRfu.partnerRecvStatuses[i] = RFU_STATUS_OK; + rfu_setRecvBuffer(TYPE_NI, i, &gRfu.partnerRecvStatuses[i], sizeof(gRfu.partnerRecvStatuses[0])); } else { - bmDisconnectFlag |= (1 << i); + disconnectFlag |= (1 << i); } } } - if (bmDisconnectFlag) + if (disconnectFlag) { - rfu_REQ_disconnect(bmDisconnectFlag); + rfu_REQ_disconnect(disconnectFlag); rfu_waitREQComplete(); } break; @@ -2110,106 +2197,103 @@ static void LmanCallback_Parent2(u8 msg, u8 param_count) case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; case LMAN_MSG_END_WAIT_CHILD_NAME: - if (Rfu.acceptSlot_flag != lman.acceptSlot_flag) + if (gRfu.acceptSlot_flag != lman.acceptSlot_flag) { - rfu_REQ_disconnect(Rfu.acceptSlot_flag ^ lman.acceptSlot_flag); + rfu_REQ_disconnect(gRfu.acceptSlot_flag ^ lman.acceptSlot_flag); rfu_waitREQComplete(); } - Rfu.state = 17; + gRfu.state = RFUSTATE_PARENT_FINALIZE_START; break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: - Rfu.linkLossRecoveryState = 1; + gRfu.linkLossRecoveryState = 1; break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: - Rfu.linkLossRecoveryState = 3; + gRfu.linkLossRecoveryState = 3; break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: - Rfu.linkLossRecoveryState = 4; - Rfu.bm_PartnerFlags &= ~lman.param[0]; + gRfu.linkLossRecoveryState = 4; + gRfu.parentSlots &= ~lman.param[0]; if (gReceivedRemoteLinkPlayers == 1) { - if (Rfu.bm_PartnerFlags == 0) - GetLinkmanErrorParams(msg); + if (gRfu.parentSlots == 0) + RfuSetErrorParams(msg); else - sub_80FB174(); + StartDisconnectNewChild(); } RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; - case 0x34: - break; + case 0x34: // ? Not a valid LMAN_MSG value case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET: break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - GetLinkmanErrorParams(msg); - Rfu.isShuttingDown = TRUE; + RfuSetErrorParams(msg); + gRfu.isShuttingDown = TRUE; break; case LMAN_MSG_REQ_API_ERROR: case LMAN_MSG_WATCH_DOG_TIMER_ERROR: case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: case LMAN_MSG_RFU_FATAL_ERROR: - GetLinkmanErrorParams(msg); + RfuSetErrorParams(msg); RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - Rfu.unk_cdb = TRUE; + gRfu.parentFinished = TRUE; break; } } -static const u8 unref_843EDF3[] = _("　あきと"); - -static void LmanCallback_Child(u8 msg, u8 param_count) +static void LinkManagerCB_Child(u8 msg, u8 param_count) { switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: - Rfu.state = 6; + gRfu.state = RFUSTATE_CHILD_CONNECT; break; case LMAN_MSG_PARENT_FOUND: - Rfu.parentId = lman.param[0]; + gRfu.parentId = lman.param[0]; break; case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; case LMAN_MSG_CONNECT_PARENT_SUCCESSED: - Rfu.child_slot = lman.param[0]; + gRfu.childSlot = lman.param[0]; break; case LMAN_MSG_CONNECT_PARENT_FAILED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: - Rfu.state = 11; - Rfu.sendStatus = RFU_STATUS_OK; - Rfu.recvStatus = RFU_STATUS_OK; - rfu_setRecvBuffer(TYPE_NI, Rfu.child_slot, &Rfu.recvStatus, 1); - rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); + gRfu.state = RFUSTATE_CHILD_TRY_JOIN; + gRfu.sendStatus = RFU_STATUS_OK; + gRfu.recvStatus = RFU_STATUS_OK; + rfu_setRecvBuffer(TYPE_NI, gRfu.childSlot, &gRfu.recvStatus, sizeof(gRfu.recvStatus)); + rfu_setRecvBuffer(TYPE_UNI, gRfu.childSlot, gRfu.childRecvQueue, sizeof(gRfu.childRecvQueue)); break; case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: - Rfu.linkLossRecoveryState = 2; - if (Rfu.recvStatus == RFU_STATUS_JOIN_GROUP_NO) + gRfu.linkLossRecoveryState = 2; + if (gRfu.recvStatus == RFU_STATUS_JOIN_GROUP_NO) break; case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: - if (Rfu.linkLossRecoveryState != 2) - Rfu.linkLossRecoveryState = 4; - if (Rfu.recvStatus != RFU_STATUS_LEAVE_GROUP) + if (gRfu.linkLossRecoveryState != 2) + gRfu.linkLossRecoveryState = 4; + if (gRfu.recvStatus != RFU_STATUS_LEAVE_GROUP) RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); - Debug_PrintString("LINK LOSS DISCONNECT!", 5, 5); + Debug_PrintString(sASCII_LinkLossDisconnect, 5, 5); if (gReceivedRemoteLinkPlayers == 1) - GetLinkmanErrorParams(msg); + RfuSetErrorParams(msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: - Rfu.linkLossRecoveryState = 1; - Debug_PrintString("LINK LOSS RECOVERY NOW", 5, 5); + gRfu.linkLossRecoveryState = 1; + Debug_PrintString(sASCII_LinkLossRecoveryNow, 5, 5); break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: - Rfu.linkLossRecoveryState = 3; - Rfu.linkRecovered = 1; + gRfu.linkLossRecoveryState = 3; + gRfu.linkRecovered = TRUE; break; - case 0x34: + case 0x34: // ? Not a valid LMAN_MSG value break; case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: @@ -2217,45 +2301,45 @@ static void LmanCallback_Child(u8 msg, u8 param_count) break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - GetLinkmanErrorParams(msg); - Rfu.isShuttingDown = TRUE; + RfuSetErrorParams(msg); + gRfu.isShuttingDown = TRUE; break; case LMAN_MSG_REQ_API_ERROR: case LMAN_MSG_WATCH_DOG_TIMER_ERROR: case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: case LMAN_MSG_RFU_FATAL_ERROR: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - GetLinkmanErrorParams(msg); - Rfu.unk_cdb = TRUE; + RfuSetErrorParams(msg); + gRfu.parentFinished = TRUE; break; } } -static void sub_80FB564(s32 bmConnectedFlag) +static void ParentResetChildRecvMetadata(s32 slot) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((bmConnectedFlag >> i) & 1) + if ((slot >> i) & 1) { - Rfu.unk_cea[i] = 0; - Rfu.unk_cee[i] = 0xFF; + gRfu.numChildRecvErrors[i] = 0; + gRfu.childRecvIds[i] = 0xFF; } } } -static u8 GetNewChildrenInUnionRoomChat(s32 bmNewChildSlot) +static u8 GetNewChildrenInUnionRoomChat(s32 emptySlotMask) { u8 ret = 0; u8 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((bmNewChildSlot >> i) & 1) + if ((emptySlotMask >> i) & 1) { - struct RfuGameData *structPtr = (void *)&gRfuLinkStatus->partner[i].gname; - if (structPtr->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) + struct RfuGameData *data = (void *)&gRfuLinkStatus->partner[i].gname; + if (data->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) ret |= (1 << i); } } @@ -2263,77 +2347,77 @@ static u8 GetNewChildrenInUnionRoomChat(s32 bmNewChildSlot) return ret; } -static void LmanCallback_Parent(u8 msg, u8 param_count) +static void LinkManagerCB_UnionRoom(u8 msg, u8 param_count) { - u8 r1; + u8 acceptSlot; switch (msg) { case LMAN_MSG_INITIALIZE_COMPLETED: - Rfu.state = 17; + gRfu.state = RFUSTATE_UR_CONNECT; break; case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED: RfuSetStatus(RFU_STATUS_NEW_CHILD_DETECTED, 0); break; case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED: - if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && !Rfu.linkClosing) + if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && !gRfu.stopNewConnections) { - u8 bmAcceptSlot = GetNewChildrenInUnionRoomChat(lman.param[0]); - if (bmAcceptSlot != 0) + u8 newChildren = GetNewChildrenInUnionRoomChat(lman.param[0]); + if (newChildren != 0) { - r1 = 1 << CountTrailingZeroes(bmAcceptSlot); - if (Rfu.unionRoomChatters == 0 && !Rfu.foundNewLeaderMaybe) + acceptSlot = 1 << Rfu_GetIndexOfNewestChild(newChildren); + if (gRfu.newChildQueue == 0 && !gRfu.playerExchangeActive) { - Rfu.bmChatLeaderMaybe = r1; - Rfu.unionRoomChatters |= (r1 ^ bmAcceptSlot); - Rfu.foundNewLeaderMaybe = TRUE; + gRfu.nextChildBits = acceptSlot; + gRfu.newChildQueue |= (acceptSlot ^ newChildren); + gRfu.playerExchangeActive = TRUE; } else { - Rfu.unionRoomChatters |= bmAcceptSlot; + gRfu.newChildQueue |= newChildren; } } - if (bmAcceptSlot != lman.param[0]) + if (newChildren != lman.param[0]) { - Rfu.bm_DisconnectSlot |= (bmAcceptSlot ^ lman.param[0]); - Rfu.unk_ce4 = 2; + gRfu.disconnectSlots |= (newChildren ^ lman.param[0]); + gRfu.disconnectMode = RFU_DISCONNECT_NORMAL; } } - else if (GetHostRFUtgtGname()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM)) + else if (GetHostRfuGameData()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM)) { rfu_REQ_disconnect(lman.acceptSlot_flag); rfu_waitREQComplete(); } - sub_80FB564(lman.param[0]); + ParentResetChildRecvMetadata(lman.param[0]); break; case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED: break; case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED: break; case LMAN_MSG_END_WAIT_CHILD_NAME: - if (GetHostRFUtgtGname()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1) + if (GetHostRfuGameData()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1) { - r1 = 1 << CountTrailingZeroes(lman.param[0]); - rfu_REQ_disconnect(lman.acceptSlot_flag ^ r1); + acceptSlot = 1 << Rfu_GetIndexOfNewestChild(lman.param[0]); + rfu_REQ_disconnect(lman.acceptSlot_flag ^ acceptSlot); rfu_waitREQComplete(); } - if (Rfu.state == 15) - Rfu.state = 16; + if (gRfu.state == RFUSTATE_UR_STOP_MANAGER_END) + gRfu.state = RFUSTATE_UR_FINALIZE; break; case LMAN_MSG_PARENT_FOUND: - Rfu.parentId = lman.param[0]; + gRfu.parentId = lman.param[0]; break; case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED: break; case LMAN_MSG_CONNECT_PARENT_SUCCESSED: - Rfu.child_slot = lman.param[0]; + gRfu.childSlot = lman.param[0]; break; case LMAN_MSG_CONNECT_PARENT_FAILED: - Rfu.state = 18; - if (Rfu.unk_ccf < 2) + gRfu.state = RFUSTATE_UR_CONNECT_END; + if (gRfu.connectParentFailures < 2) { - Rfu.unk_ccf++; - CreateTask(sub_80FC028, 2); + gRfu.connectParentFailures++; + CreateTask(Task_TryConnectToUnionRoomParent, 2); } else { @@ -2341,52 +2425,54 @@ static void LmanCallback_Parent(u8 msg, u8 param_count) } break; case LMAN_MSG_CHILD_NAME_SEND_COMPLETED: - Rfu.state = 13; + gRfu.state = RFUSTATE_UR_PLAYER_EXCHANGE; RfuSetStatus(RFU_STATUS_CHILD_SEND_COMPLETE, 0); - rfu_setRecvBuffer(TYPE_UNI, Rfu.child_slot, Rfu.unk_c3f, sizeof(Rfu.unk_c3f)); + rfu_setRecvBuffer(TYPE_UNI, gRfu.childSlot, gRfu.childRecvQueue, sizeof(gRfu.childRecvQueue)); break; case LMAN_MSG_CHILD_NAME_SEND_FAILED_AND_DISCONNECTED: RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY: if (lman.acceptSlot_flag & lman.param[0]) - Rfu.linkLossRecoveryState = 1; + gRfu.linkLossRecoveryState = 1; break; case LMAN_MSG_LINK_RECOVERY_SUCCESSED: - Rfu.linkLossRecoveryState = 3; + gRfu.linkLossRecoveryState = 3; if (gRfuLinkStatus->parentChild == MODE_CHILD) - Rfu.linkRecovered = 1; + gRfu.linkRecovered = TRUE; break; case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED: - Rfu.linkLossRecoveryState = 2; + gRfu.linkLossRecoveryState = 2; // fallthrough case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED: - if (Rfu.linkLossRecoveryState != 2) - Rfu.linkLossRecoveryState = 4; - if (Rfu.parent_child == MODE_PARENT) + if (gRfu.linkLossRecoveryState != 2) + gRfu.linkLossRecoveryState = 4; + if (gRfu.parentChild == MODE_PARENT) { if (gReceivedRemoteLinkPlayers == 1) { - Rfu.bm_PartnerFlags &= ~(lman.param[0]); - if (Rfu.bm_PartnerFlags == 0) - GetLinkmanErrorParams(msg); + gRfu.parentSlots &= ~(lman.param[0]); + if (gRfu.parentSlots == 0) + RfuSetErrorParams(msg); else - sub_80FB174(); + StartDisconnectNewChild(); } } - else if (Rfu.unk_ce4 != 2 && gReceivedRemoteLinkPlayers == 1) + else if (gRfu.disconnectMode != RFU_DISCONNECT_NORMAL && gReceivedRemoteLinkPlayers == 1) { - GetLinkmanErrorParams(msg); + RfuSetErrorParams(msg); rfu_LMAN_stopManager(0); } - if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && lman.pcswitch_flag == 0 && FuncIsActiveTask(Task_LinkRfu_UnionRoomListen) == TRUE) - Rfu.state = 17; + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL + && lman.pcswitch_flag == 0 && + FuncIsActiveTask(Task_UnionRoomListen) == TRUE) + gRfu.state = RFUSTATE_UR_CONNECT; RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg); break; case LMAN_MSG_LINK_DISCONNECTED_BY_USER: - Rfu.bm_DisconnectSlot = 0; + gRfu.disconnectSlots = 0; break; case LMAN_MSG_RFU_POWER_DOWN: case LMAN_MSG_MANAGER_STOPPED: @@ -2394,34 +2480,34 @@ static void LmanCallback_Parent(u8 msg, u8 param_count) break; case LMAN_MSG_LMAN_API_ERROR_RETURN: RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - GetLinkmanErrorParams(msg); - Rfu.isShuttingDown = TRUE; + RfuSetErrorParams(msg); + gRfu.isShuttingDown = TRUE; break; case LMAN_MSG_REQ_API_ERROR: case LMAN_MSG_WATCH_DOG_TIMER_ERROR: case LMAN_MSG_CLOCK_SLAVE_MS_CHANGE_ERROR_BY_DMA: case LMAN_MSG_RFU_FATAL_ERROR: - GetLinkmanErrorParams(msg); + RfuSetErrorParams(msg); RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg); - Rfu.unk_cdb = FALSE; + gRfu.parentFinished = FALSE; break; } } -void sub_80FB9D0(void) +void RfuSetNormalDisconnectMode(void) { - Rfu.unk_ce4 = 2; + gRfu.disconnectMode = RFU_DISCONNECT_NORMAL; } -void RfuSetStatus(u8 status, u16 msg) +void RfuSetStatus(u8 status, u16 errorInfo) { - Rfu.status = status; - Rfu.linkman_msg = msg; + gRfu.status = status; + gRfu.errorInfo = errorInfo; } u8 RfuGetStatus(void) { - return Rfu.status; + return gRfu.status; } bool32 RfuHasErrored(void) @@ -2433,17 +2519,17 @@ bool32 RfuHasErrored(void) return FALSE; } -bool32 RfuHasFoundNewLeader(void) +bool32 Rfu_IsPlayerExchangeActive(void) { - return Rfu.foundNewLeaderMaybe; + return gRfu.playerExchangeActive; } bool8 Rfu_IsMaster(void) { - return Rfu.parent_child; + return gRfu.parentChild; } -void RFUVSync(void) +void RfuVSync(void) { rfu_LMAN_syncVBlank(); } @@ -2453,14 +2539,15 @@ void ClearRecvCommands(void) CpuFill32(0, gRecvCmds, sizeof(gRecvCmds)); } -static void sub_80FBA64(void) +static void VBlank_RfuIdle(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -static void sub_80FBA78(void) +// Unused +static void Debug_RfuIdle(void) { s32 i; @@ -2468,14 +2555,14 @@ static void sub_80FBA78(void) FreeAllSpritePalettes(); ResetTasks(); ResetPaletteFade(); - SetVBlankCallback(sub_80FBA64); + SetVBlankCallback(VBlank_RfuIdle); if (IsWirelessAdapterConnected()) { gLinkType = LINKTYPE_TRADE; SetWirelessCommType1(); OpenLink(); SeedRng(gMain.vblankCounter2); - for (i = 0; i < RFU_CHILD_MAX; i++) + for (i = 0; i < TRAINER_ID_LENGTH; i++) gSaveBlock2Ptr->playerTrainerId[i] = Random() % 256; SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG2_ON | DISPCNT_OBJ_1D_MAP); @@ -2483,29 +2570,29 @@ static void sub_80FBA78(void) AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); - LinkRfu_CreateIdleTask(); - SetMainCallback2(sub_80FBB74); + CreateTask_RfuIdle(); + SetMainCallback2(CB2_RfuIdle); } } bool32 IsUnionRoomListenTaskActive(void) { - return FuncIsActiveTask(Task_LinkRfu_UnionRoomListen); + return FuncIsActiveTask(Task_UnionRoomListen); } -void LinkRfu_CreateIdleTask(void) +void CreateTask_RfuIdle(void) { - if (!FuncIsActiveTask(Task_idle)) - Rfu.idleTaskId = CreateTask(Task_idle, 0); + if (!FuncIsActiveTask(Task_Idle)) + gRfu.idleTaskId = CreateTask(Task_Idle, 0); } -void LinkRfu_DestroyIdleTask(void) +void DestroyTask_RfuIdle(void) { - if (FuncIsActiveTask(Task_idle) == TRUE) - DestroyTask(Rfu.idleTaskId); + if (FuncIsActiveTask(Task_Idle) == TRUE) + DestroyTask(gRfu.idleTaskId); } -static void sub_80FBB74(void) +static void CB2_RfuIdle(void) { RunTasks(); AnimateSprites(); @@ -2513,35 +2600,35 @@ static void sub_80FBB74(void) UpdatePaletteFade(); } -void InitializeRfuLinkManager_LinkLeader(u32 availSlots) +void InitializeRfuLinkManager_LinkLeader(u32 groupMax) { - Rfu.parent_child = MODE_PARENT; - CopyPlayerNameToUnameBuffer(); - rfu_LMAN_initializeManager(LmanCallback_Parent2, NULL); + gRfu.parentChild = MODE_PARENT; + SetHostRfuUsername(); + rfu_LMAN_initializeManager(LinkManagerCB_Parent, NULL); sRfuReqConfig = sRfuReqConfigTemplate; - sRfuReqConfig.availSlot_flag = sAvailSlots[availSlots - 1]; - CreateTask_LinkLeaderSearchForChildren(); + sRfuReqConfig.availSlot_flag = sAvailSlots[groupMax - 1]; + CreateTask_ParentSearchForChildren(); } void InitializeRfuLinkManager_JoinGroup(void) { - Rfu.parent_child = MODE_CHILD; - CopyPlayerNameToUnameBuffer(); - rfu_LMAN_initializeManager(LmanCallback_Child, MscCallback_Child); - CreateTask_JoinGroupSearchForParent(); + gRfu.parentChild = MODE_CHILD; + SetHostRfuUsername(); + rfu_LMAN_initializeManager(LinkManagerCB_Child, MscCallback_Child); + CreateTask_ChildSearchForParent(); } void InitializeRfuLinkManager_EnterUnionRoom(void) { if (QL_IS_PLAYBACK_STATE) return; - Rfu.parent_child = 2; - CopyPlayerNameToUnameBuffer(); - rfu_LMAN_initializeManager(LmanCallback_Parent, NULL); + gRfu.parentChild = MODE_P_C_SWITCH; + SetHostRfuUsername(); + rfu_LMAN_initializeManager(LinkManagerCB_UnionRoom, NULL); sRfuReqConfig = sRfuReqConfigTemplate; sRfuReqConfig.linkRecovery_enable = 0; sRfuReqConfig.linkRecovery_period = 600; - Rfu.searchTaskId = CreateTask(Task_LinkRfu_UnionRoomListen, 1); + gRfu.searchTaskId = CreateTask(Task_UnionRoomListen, 1); } static u16 ReadU16(const void *ptr) @@ -2557,169 +2644,186 @@ static u16 ReadU16(const void *ptr) * Returns 0xFF if not found. * ================================================================ */ -static u8 GetPartnerIndexByNameAndTrainerID(const u8 *trainerName, u16 trainerId) +static u8 GetPartnerIndexByNameAndTrainerID(const u8 *name, u16 trainerId) { u8 i; - u8 ret = 0xFF; + u8 idx = 0xFF; for (i = 0; i < RFU_CHILD_MAX; i++) { - u16 partnerTrainerId = ReadU16(((struct RfuGameData *)gRfuLinkStatus->partner[i].gname)->unk_00.playerTrainerId); + u16 partnerTrainerId = ReadU16(((struct RfuGameData *)gRfuLinkStatus->partner[i].gname)->compatibility.playerTrainerId); if (IsRfuSerialNumberValid(gRfuLinkStatus->partner[i].serialNo) - && !StringCompare(trainerName, gRfuLinkStatus->partner[i].uname) + && !StringCompare(name, gRfuLinkStatus->partner[i].uname) && trainerId == partnerTrainerId) { - ret = i; + idx = i; if (gRfuLinkStatus->partner[i].slot != 0xFF) break; } } - return ret; + return idx; } -static void RfuReqDisconnectSlot(u32 bmDisconnectSlot) +static void RfuReqDisconnectSlot(u32 slot) { - rfu_REQ_disconnect(bmDisconnectSlot); + rfu_REQ_disconnect(slot); rfu_waitREQComplete(); - Rfu.bm_PartnerFlags &= ~(bmDisconnectSlot); - rfu_clearSlot(TYPE_UNI_SEND, Rfu.unk_cda); - rfu_UNI_setSendData(Rfu.bm_PartnerFlags, Rfu.recvCmds, 70); - Rfu.unk_cda = CountTrailingZeroes(Rfu.bm_PartnerFlags); + gRfu.parentSlots &= ~slot; + rfu_clearSlot(TYPE_UNI_SEND, gRfu.parentSendSlot); + rfu_UNI_setSendData(gRfu.parentSlots, gRfu.recvCmds, sizeof(gRfu.recvCmds)); + gRfu.parentSendSlot = Rfu_GetIndexOfNewestChild(gRfu.parentSlots); } void RequestDisconnectSlotByTrainerNameAndId(const u8 *trainerName, u16 trainerId) { - u8 var = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); - if (var != 0xFF) - RfuReqDisconnectSlot(1 << var); + u8 index = GetPartnerIndexByNameAndTrainerID(trainerName, trainerId); + if (index != 0xFF) + RfuReqDisconnectSlot(1 << index); } -void sub_80FBD6C(u32 a0) +void Rfu_DisconnectPlayerById(u32 playerIdx) { - if (a0 != 0) + if (playerIdx != 0) { s32 i; - u8 var = 0; + u8 toDisconnect = 0; for (i = 0; i < RFU_CHILD_MAX; i++) { - if (Rfu.linkPlayerIdx[i] == a0 && (Rfu.bm_PartnerFlags >> i) & 1) - var |= 1 << i; + if (gRfu.linkPlayerIdx[i] == playerIdx && (gRfu.parentSlots >> i) & 1) + toDisconnect |= 1 << i; } - if (var) - sub_80FBE20(var, 2); + if (toDisconnect) + SendDisconnectCommand(toDisconnect, RFU_DISCONNECT_NORMAL); } } -static void sub_80FBDB8(u8 taskId) +#define tDisconnectPlayers data[0] +#define tDisconnectMode data[1] + +static void Task_SendDisconnectCommand(u8 taskId) { - if (IsSendCmdComplete() && !Rfu.foundNewLeaderMaybe) + if (IsSendCmdComplete() && !gRfu.playerExchangeActive) { - RfuPrepareSendBuffer(RFUCMD_PARENT_DISCONNECT); - gSendCmd[1] = gTasks[taskId].data[0]; - gSendCmd[2] = gTasks[taskId].data[1]; - Rfu.playerCount -= sNumSetBits[gTasks[taskId].data[0]]; - gSendCmd[3] = Rfu.playerCount; + RfuPrepareSendBuffer(RFUCMD_DISCONNECT); + gSendCmd[1] = gTasks[taskId].tDisconnectPlayers; + gSendCmd[2] = gTasks[taskId].tDisconnectMode; + gRfu.playerCount -= sPlayerBitsToCount[gTasks[taskId].tDisconnectPlayers]; + gSendCmd[3] = gRfu.playerCount; DestroyTask(taskId); } } -static void sub_80FBE20(u32 a0, u32 a1) +static void SendDisconnectCommand(u32 playersToDisconnect, u32 disconnectMode) { - u8 taskId = FindTaskIdByFunc(sub_80FBDB8); - if (taskId == 0xFF) + u8 taskId = FindTaskIdByFunc(Task_SendDisconnectCommand); + if (taskId == TASK_NONE) { - taskId = CreateTask(sub_80FBDB8, 5); - gTasks[taskId].data[0] = a0; + taskId = CreateTask(Task_SendDisconnectCommand, 5); + gTasks[taskId].tDisconnectPlayers = playersToDisconnect; } else { - gTasks[taskId].data[0] |= a0; + // Task is already active, just add the new players to disconnect + gTasks[taskId].tDisconnectPlayers |= playersToDisconnect; } - gTasks[taskId].data[1] = a1; + gTasks[taskId].tDisconnectMode = disconnectMode; } +#undef tDisconnectPlayers +#undef tDisconnectMode + +#define tTime data[15] + static void Task_RfuReconnectWithParent(u8 taskId) { s16 *data = gTasks[taskId].data; - if (ContactedByParentAttemptingToReconnect()) + if (CanTryReconnectParent()) { u8 id = GetPartnerIndexByNameAndTrainerID((u8 *)data, ReadU16(&data[8])); if (id != 0xFF) { if (gRfuLinkStatus->partner[id].slot != 0xFF) { - Rfu.reconnectedParentIdx = id; - if (IsParentSuccessfullyReconnected()) + gRfu.reconnectParentId = id; + if (TryReconnectParent()) DestroyTask(taskId); } - else if (GetHostRFUtgtGname()->activity == ACTIVITY_WCARD2 || GetHostRFUtgtGname()->activity == ACTIVITY_WNEWS2) + else if (GetHostRfuGameData()->activity == ACTIVITY_WCARD2 + || GetHostRfuGameData()->activity == ACTIVITY_WNEWS2) { - data[15]++; + tTime++; } else { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); + // Error, unable to reconnect to parent + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); DestroyTask(taskId); } } else { - data[15]++; - Rfu.reconnectedParentIdx = id; + tTime++; + gRfu.reconnectParentId = id; } } else { - data[15]++; + tTime++; } - if (data[15] > 240) + if (tTime > 240) { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); + // Timeout error + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); DestroyTask(taskId); } } -void CreateTask_RfuReconnectWithParent(const u8 *trainerName, u16 trainerId) +#undef tTime + +void CreateTask_RfuReconnectWithParent(const u8 *name, u16 trainerId) { u8 taskId; s16 *data; - Rfu.status = RFU_STATUS_OK; + gRfu.status = RFU_STATUS_OK; taskId = CreateTask(Task_RfuReconnectWithParent, 3); data = gTasks[taskId].data; - StringCopy((u8 *)(data), trainerName); + StringCopy((u8 *)(data), name); data[8] = trainerId; } -static bool32 ShouldRejectPartnerConnectionBasedOnActivity(s16 activity, struct RfuGameData *partnerGname) +static bool32 IsPartnerActivityIncompatible(s16 activity, struct RfuGameData *partner) { - if (GetHostRFUtgtGname()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) + if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { - if (partnerGname->activity != (ACTIVITY_CHAT | IN_UNION_ROOM)) + // Host trying to chat, but partner isn't + if (partner->activity != (ACTIVITY_CHAT | IN_UNION_ROOM)) return TRUE; } - else if (partnerGname->activity != IN_UNION_ROOM) + else if (partner->activity != IN_UNION_ROOM) { + // Partner not in union room return TRUE; } else if (activity == (ACTIVITY_TRADE | IN_UNION_ROOM)) { - struct RfuGameData *myTradeGname = (struct RfuGameData *)&Rfu.tgtData.gname; - if (myTradeGname->species == SPECIES_EGG) + // Verify that the trade offered hasn't changed + struct RfuGameData *original = (struct RfuGameData *)&gRfu.parent.gname; + if (original->tradeSpecies == SPECIES_EGG) { - if (partnerGname->species == myTradeGname->species) + if (partner->tradeSpecies == original->tradeSpecies) return FALSE; else return TRUE; } - else if (partnerGname->species != myTradeGname->species - || partnerGname->level != myTradeGname->level - || partnerGname->type != myTradeGname->type) + else if (partner->tradeSpecies != original->tradeSpecies + || partner->tradeLevel != original->tradeLevel + || partner->tradeType != original->tradeType) { return TRUE; } @@ -2728,79 +2832,92 @@ static bool32 ShouldRejectPartnerConnectionBasedOnActivity(s16 activity, struct return FALSE; } -static void sub_80FC028(u8 taskId) +#define tTime data[0] +#define tActivity data[1] + +static void Task_TryConnectToUnionRoomParent(u8 taskId) { - if (Rfu.status == RFU_STATUS_NEW_CHILD_DETECTED) + // Stop task if player is the new parent + if (gRfu.status == RFU_STATUS_NEW_CHILD_DETECTED) DestroyTask(taskId); if (++gTasks[taskId].data[0] > 300) { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); + // Timeout error + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); DestroyTask(taskId); } - if (Rfu.parentId != 0 && lman.parent_child == MODE_CHILD) + // Check if parent should be searched for + if (gRfu.parentId != 0 && lman.parent_child == MODE_CHILD) { - u16 trainerId = ReadU16(((struct RfuGameData *)&Rfu.tgtData.gname)->unk_00.playerTrainerId); - u8 id = GetPartnerIndexByNameAndTrainerID(Rfu.tgtData.uname, trainerId); + // Search for parent + u16 trainerId = ReadU16(((struct RfuGameData *)&gRfu.parent.gname)->compatibility.playerTrainerId); + u8 id = GetPartnerIndexByNameAndTrainerID(gRfu.parent.uname, trainerId); if (id != 0xFF) { - if (!ShouldRejectPartnerConnectionBasedOnActivity(gTasks[taskId].data[1], (struct RfuGameData *)&gRfuLinkStatus->partner[id].gname)) + // Parent found, try to connect + if (!IsPartnerActivityIncompatible(gTasks[taskId].data[1], (struct RfuGameData *)&gRfuLinkStatus->partner[id].gname)) { if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 90)) { - Rfu.state = 10; + // Succesfully connected to parent + gRfu.state = RFUSTATE_CONNECTED; DestroyTask(taskId); } } else { - RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, 0x7000); + // Incompatible partner activity + RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7); DestroyTask(taskId); } } } } -void sub_80FC114(const u8 *name, struct RfuGameData *structPtr, u8 activity) +void TryConnectToUnionRoomParent(const u8 *name, struct RfuGameData *parent, u8 activity) { - u8 taskId, taskId2; + u8 taskId, listenTaskId; - Rfu.unk_ccf = 0; - Rfu.status = RFU_STATUS_OK; - StringCopy(Rfu.tgtData.uname, name); - memcpy(Rfu.tgtData.gname, structPtr, RFU_GAME_NAME_LENGTH); + gRfu.connectParentFailures = 0; + gRfu.status = RFU_STATUS_OK; + StringCopy(gRfu.parent.uname, name); + memcpy(gRfu.parent.gname, parent, RFU_GAME_NAME_LENGTH); rfu_LMAN_forceChangeSP(); - taskId = CreateTask(sub_80FC028, 2); - gTasks[taskId].data[1] = activity; - taskId2 = FindTaskIdByFunc(Task_LinkRfu_UnionRoomListen); + taskId = CreateTask(Task_TryConnectToUnionRoomParent, 2); + gTasks[taskId].tActivity = activity; + listenTaskId = FindTaskIdByFunc(Task_UnionRoomListen); if (activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { - if (taskId2 != 0xFF) - gTasks[taskId2].data[7] = 1; + if (listenTaskId != TASK_NONE) + gTasks[listenTaskId].tConnectingForChat = TRUE; } else { - if (taskId2 != 0xFF) - gTasks[taskId2].data[7] = 0; + if (listenTaskId != TASK_NONE) + gTasks[listenTaskId].tConnectingForChat = FALSE; } } bool8 IsRfuRecoveringFromLinkLoss(void) { - if (Rfu.linkLossRecoveryState == 1) + if (gRfu.linkLossRecoveryState == 1) return TRUE; else return FALSE; } -bool32 sub_80FC1CC(void) +bool32 IsRfuCommunicatingWithAllChildren(void) { s32 i; for (i = 0; i < RFU_CHILD_MAX; i++) { - if ((lman.acceptSlot_flag >> i) & 1 && Rfu.partnerSendStatuses[i] == 0) + // RFU_STATUS_OK is the default status. + // If any connected child is receiving a status other + // than OK, then the parent is communicating with them + if ((lman.acceptSlot_flag >> i) & 1 && gRfu.partnerSendStatuses[i] == RFU_STATUS_OK) return FALSE; } @@ -2812,30 +2929,17 @@ static void Debug_PrintEmpty(void) s32 i; for (i = 0; i < 20; i++) - Debug_PrintString(" ", 0, i); + Debug_PrintString(sASCII_30Spaces, 0, i); } -static const char gUnknown_843EE47[16] = { - ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', - '\0' -}; - -static const char gUnknown_843EE57[9] = { - ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', - '\0' -}; - -static const char gUnknown_843EE60[] = {' ', '\0'}; -static const char gUnknown_843EE62[] = {'*', '\0'}; - static void Debug_PrintStatus(void) { s32 i, j; - Debug_PrintNum(GetBlockReceivedStatus(), 0x1C, 0x13, 2); - Debug_PrintNum(gRfuLinkStatus->connSlotFlag, 0x14, 1, 1); - Debug_PrintNum(gRfuLinkStatus->linkLossSlotFlag, 0x17, 1, 1); - if (Rfu.parent_child == MODE_PARENT) + Debug_PrintNum(GetBlockReceivedStatus(), 28, 19, 2); + Debug_PrintNum(gRfuLinkStatus->connSlotFlag, 20, 1, 1); + Debug_PrintNum(gRfuLinkStatus->linkLossSlotFlag, 23, 1, 1); + if (gRfu.parentChild == MODE_PARENT) { for (i = 0; i < RFU_CHILD_MAX; i++) { @@ -2843,29 +2947,27 @@ static void Debug_PrintStatus(void) { Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); Debug_PrintString((void *) &gRfuLinkStatus->partner[i].gname, 6, i + 3); - Debug_PrintString(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); + Debug_PrintString(gRfuLinkStatus->partner[i].uname, 22, i + 3); } } for (i = 0; i < RFU_CHILD_MAX; i++) { - for (j = 0; j < 14; j++) - { - Debug_PrintNum(Rfu.main_UNI_recvBuffer[i][j], j * 2, i + 11, 2); - } + for (j = 0; j < COMM_SLOT_LENGTH; j++) + Debug_PrintNum(gRfu.childRecvBuffer[i][j], j * 2, i + 11, 2); } - Debug_PrintString("NOWSLOT", 1, 0xF); + Debug_PrintString(sASCII_NowSlot, 1, 15); } else if (gRfuLinkStatus->connSlotFlag != 0 && gRfuLinkStatus->getNameFlag != 0) { for (i = 0; i < RFU_CHILD_MAX; i++) { Debug_PrintNum(0, 1, i + 3, 4); - Debug_PrintString(gUnknown_843EE47, 6, i + 3); - Debug_PrintString(gUnknown_843EE57, 0x16, i + 3); + Debug_PrintString(sASCII_15Spaces, 6, i + 3); + Debug_PrintString(sASCII_8Spaces, 22, i + 3); } - Debug_PrintNum(gRfuLinkStatus->partner[Rfu.child_slot].serialNo, 1, 3, 4); - Debug_PrintString(gRfuLinkStatus->partner[Rfu.child_slot].gname, 6, 3); - Debug_PrintString(gRfuLinkStatus->partner[Rfu.child_slot].uname, 0x16, 3); + Debug_PrintNum(gRfuLinkStatus->partner[gRfu.childSlot].serialNo, 1, 3, 4); + Debug_PrintString(gRfuLinkStatus->partner[gRfu.childSlot].gname, 6, 3); + Debug_PrintString(gRfuLinkStatus->partner[gRfu.childSlot].uname, 22, 3); } else { @@ -2875,43 +2977,29 @@ static void Debug_PrintStatus(void) { Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4); Debug_PrintNum(gRfuLinkStatus->partner[i].id, 6, i + 3, 4); - Debug_PrintString(gRfuLinkStatus->partner[i].uname, 0x16, i + 3); + Debug_PrintString(gRfuLinkStatus->partner[i].uname, 22, i + 3); } } for (; i < RFU_CHILD_MAX; i++) { Debug_PrintNum(0, 1, i + 3, 4); - Debug_PrintString(gUnknown_843EE47, 6, i + 3); - Debug_PrintString(gUnknown_843EE57, 0x16, i + 3); + Debug_PrintString(sASCII_15Spaces, 6, i + 3); + Debug_PrintString(sASCII_8Spaces, 22, i + 3); } } } -static const char gUnknown_843EE6C[][12] = { - " ", - "CLOCK DRIFT", - "BUSY SEND ", - "CMD REJECT ", - "CLOCK SLAVE" -}; - -static const char gUnknown_843EEA8[][8] = { - "CHILD ", - "PARENT", - "SEARCH" -}; - static u32 GetRfuSendQueueLength(void) { - return Rfu.sendQueue.count; + return gRfu.sendQueue.count; } u32 GetRfuRecvQueueLength(void) { - return Rfu.recvQueue.count; + return gRfu.recvQueue.count; } -static void Task_idle(u8 taskId) +static void Task_Idle(u8 taskId) { } diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c index 647658c7e..f47b71829 100644 --- a/src/link_rfu_3.c +++ b/src/link_rfu_3.c @@ -298,10 +298,8 @@ void RfuRecvQueue_Reset(struct RfuRecvQueue *queue) for (i = 0; i < RECV_QUEUE_NUM_SLOTS; i++) { - for (j = 0; j < RECV_QUEUE_SLOT_LENGTH; j++) - { + for (j = 0; j < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; j++) queue->slots[i][j] = 0; - } } queue->send_slot = 0; queue->recv_slot = 0; @@ -316,10 +314,8 @@ void RfuSendQueue_Reset(struct RfuSendQueue *queue) for (i = 0; i < SEND_QUEUE_NUM_SLOTS; i++) { - for (j = 0; j < SEND_QUEUE_SLOT_LENGTH; j++) - { + for (j = 0; j < COMM_SLOT_LENGTH; j++) queue->slots[i][j] = 0; - } } queue->send_slot = 0; queue->recv_slot = 0; @@ -356,26 +352,20 @@ void RfuRecvQueue_Enqueue(struct RfuRecvQueue *queue, u8 *src) imeBak = REG_IME; REG_IME = 0; count = 0; - for (i = 0; i < RECV_QUEUE_SLOT_LENGTH; i += RECV_QUEUE_SLOT_LENGTH / MAX_RFU_PLAYERS) + for (i = 0; i < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; i += COMM_SLOT_LENGTH) { if (src[i] == 0 && src[i + 1] == 0) - { count++; - } } if (count != MAX_RFU_PLAYERS) { - for (i = 0; i < RECV_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; i++) queue->slots[queue->recv_slot][i] = src[i]; - } queue->recv_slot++; queue->recv_slot %= RECV_QUEUE_NUM_SLOTS; queue->count++; - for (i = 0; i < RECV_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; i++) src[i] = 0; - } } REG_IME = imeBak; } @@ -394,26 +384,20 @@ void RfuSendQueue_Enqueue(struct RfuSendQueue *queue, u8 *src) { imeBak = REG_IME; REG_IME = 0; - for (i = 0; i < SEND_QUEUE_SLOT_LENGTH; i++) + for (i = 0; i < COMM_SLOT_LENGTH; i++) { if (src[i] != 0) - { break; - } } - if (i != SEND_QUEUE_SLOT_LENGTH) + if (i != COMM_SLOT_LENGTH) { - for (i = 0; i < SEND_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH; i++) queue->slots[queue->recv_slot][i] = src[i]; - } queue->recv_slot++; queue->recv_slot %= SEND_QUEUE_NUM_SLOTS; queue->count++; - for (i = 0; i < SEND_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH; i++) src[i] = 0; - } } REG_IME = imeBak; } @@ -432,17 +416,13 @@ bool8 RfuRecvQueue_Dequeue(struct RfuRecvQueue *queue, u8 *dest) REG_IME = 0; if (queue->recv_slot == queue->send_slot || queue->full) { - for (i = 0; i < RECV_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; i++) dest[i] = 0; - } REG_IME = imeBak; return FALSE; } - for (i = 0; i < RECV_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH * MAX_RFU_PLAYERS; i++) dest[i] = queue->slots[queue->send_slot][i]; - } queue->send_slot++; queue->send_slot %= RECV_QUEUE_NUM_SLOTS; queue->count--; @@ -456,15 +436,11 @@ bool8 RfuSendQueue_Dequeue(struct RfuSendQueue *queue, u8 *dest) u16 imeBak; if (queue->recv_slot == queue->send_slot || queue->full) - { return FALSE; - } imeBak = REG_IME; REG_IME = 0; - for (i = 0; i < SEND_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH; i++) dest[i] = queue->slots[queue->send_slot][i]; - } queue->send_slot++; queue->send_slot %= SEND_QUEUE_NUM_SLOTS; queue->count--; @@ -482,10 +458,8 @@ void RfuBackupQueue_Enqueue(struct RfuBackupQueue *queue, const u8 *dest) } else { - for (i = 0; i < BACKUP_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH; i++) queue->slots[queue->recv_slot][i] = dest[i]; - } queue->recv_slot++; queue->recv_slot %= BACKUP_QUEUE_NUM_SLOTS; if (queue->count < BACKUP_QUEUE_NUM_SLOTS) @@ -509,10 +483,8 @@ bool8 RfuBackupQueue_Dequeue(struct RfuBackupQueue *queue, u8 *dest) } if (dest != NULL) { - for (i = 0; i < BACKUP_QUEUE_SLOT_LENGTH; i++) - { + for (i = 0; i < COMM_SLOT_LENGTH; i++) dest[i] = queue->slots[queue->send_slot][i]; - } } queue->send_slot++; queue->send_slot %= BACKUP_QUEUE_NUM_SLOTS; @@ -672,30 +644,30 @@ static u8 GetConnectedChildStrength(u8 maxFlags) return 0; } -void InitHostRFUtgtGname(struct RfuGameData *data, u8 activity, bool32 started, s32 child_sprite_genders) +void InitHostRFUtgtGname(struct RfuGameData *data, u8 activity, bool32 startedActivity, s32 partnerInfo) { s32 i; for (i = 0; i < 2; i++) { - data->unk_00.playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i]; + data->compatibility.playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i]; } for (i = 0; i < RFU_CHILD_MAX; i++) { - data->child_sprite_gender[i] = child_sprite_genders; - child_sprite_genders >>= 8; + data->partnerInfo[i] = partnerInfo; + partnerInfo >>= 8; } data->playerGender = gSaveBlock2Ptr->playerGender; data->activity = activity; - data->started = started; - data->unk_00.language = GAME_LANGUAGE; - data->unk_00.version = GAME_VERSION; - data->unk_00.hasNews = FALSE; - data->unk_00.hasCard = FALSE; - data->unk_00.unknown = FALSE; - 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); + data->startedActivity = startedActivity; + data->compatibility.language = GAME_LANGUAGE; + data->compatibility.version = GAME_VERSION; + data->compatibility.hasNews = FALSE; + data->compatibility.hasCard = FALSE; + data->compatibility.unknown = FALSE; + data->compatibility.isChampion = FlagGet(FLAG_SYS_CAN_LINK_WITH_RS); + data->compatibility.hasNationalDex = IsNationalPokedexEnabled(); + data->compatibility.gameClear = FlagGet(FLAG_SYS_GAME_CLEAR); } /* @@ -749,7 +721,7 @@ bool8 LinkRfu_GetNameIfCompatible(struct RfuGameData *gname, u8 *uname, u8 idx) bool8 LinkRfu_GetNameIfSerial7F7D(struct RfuGameData *gname, u8 *uname, u8 idx) { bool8 retVal = FALSE; - if (gRfuLinkStatus->partner[idx].serialNo == RFU_SERIAL_7F7D) + if (gRfuLinkStatus->partner[idx].serialNo == RFU_SERIAL_WONDER_DISTRIBUTOR) { memcpy(gname, gRfuLinkStatus->partner[idx].gname, RFU_GAME_NAME_LENGTH); memcpy(uname, gRfuLinkStatus->partner[idx].uname, RFU_USER_NAME_LENGTH); diff --git a/src/main.c b/src/main.c index 368638022..5efaaf6d1 100644 --- a/src/main.c +++ b/src/main.c @@ -358,7 +358,7 @@ extern void ProcessDma3Requests(void); static void VBlankIntr(void) { if (gWirelessCommType) - RFUVSync(); + RfuVSync(); else if (!gLinkVSyncDisabled) LinkVSync(); diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c index 3dfce13a0..380e0b264 100644 --- a/src/mystery_gift_menu.c +++ b/src/mystery_gift_menu.c @@ -354,7 +354,7 @@ void vblankcb_mystery_gift_e_reader_run(void) TransferPlttBuffer(); } -void c2_mystery_gift_e_reader_run(void) +void CB2_MysteryGiftEReader(void) { RunTasks(); RunTextPrinters(); @@ -434,7 +434,7 @@ void c2_mystery_gift(void) { if (HandleMysteryGiftOrEReaderSetup(0)) { - SetMainCallback2(c2_mystery_gift_e_reader_run); + SetMainCallback2(CB2_MysteryGiftEReader); gGiftIsFromEReader = FALSE; task_add_00_mystery_gift(); } @@ -444,7 +444,7 @@ void c2_ereader(void) { if (HandleMysteryGiftOrEReaderSetup(1)) { - SetMainCallback2(c2_mystery_gift_e_reader_run); + SetMainCallback2(CB2_MysteryGiftEReader); gGiftIsFromEReader = TRUE; task_add_00_ereader(); } diff --git a/src/overworld.c b/src/overworld.c index 8c6037ca3..61e1a1db7 100644 --- a/src/overworld.c +++ b/src/overworld.c @@ -3239,7 +3239,7 @@ bool32 IsSendingKeysOverCable(void) static u32 GetLinkSendQueueLength(void) { if (gWirelessCommType != 0) - return Rfu.sendQueue.count; + return gRfu.sendQueue.count; else return gLink.sendQueue.count; } diff --git a/src/party_menu.c b/src/party_menu.c index 7725a3c3d..84b9b5807 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -3851,7 +3851,7 @@ static void CursorCB_Register(u8 taskId) u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); u8 isEventLegal = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_EVENT_LEGAL); - switch (CanRegisterMonForTradingBoard(*(struct RfuGameCompatibilityData *)GetHostRFUtgtGname(), species2, species, isEventLegal)) + switch (CanRegisterMonForTradingBoard(*(struct RfuGameCompatibilityData *)GetHostRfuGameData(), species2, species, isEventLegal)) { case CANT_REGISTER_MON: StringExpandPlaceholders(gStringVar4, gText_PkmnCantBeTradedNow); @@ -3877,7 +3877,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 isEventLegal = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_EVENT_LEGAL); - u32 stringId = GetUnionRoomTradeMessageId(*(struct RfuGameCompatibilityData *)GetHostRFUtgtGname(), gPartnerTgtGnameSub, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, isEventLegal); + u32 stringId = GetUnionRoomTradeMessageId(*(struct RfuGameCompatibilityData *)GetHostRfuGameData(), gPartnerTgtGnameSub, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, isEventLegal); if (stringId != UR_TRADE_MSG_NONE) { diff --git a/src/pokemon_jump.c b/src/pokemon_jump.c index 39e13f786..c2e89b8be 100644 --- a/src/pokemon_jump.c +++ b/src/pokemon_jump.c @@ -2540,7 +2540,7 @@ static int GetPlayersAtJumpPeak(void) static bool32 AreLinkQueuesEmpty(void) { - return !Rfu.recvQueue.count && !Rfu.sendQueue.count; + return !gRfu.recvQueue.count && !gRfu.sendQueue.count; } static int GetNumPlayersForBonus(u8 *arg0) diff --git a/src/rfu_union_tool.c b/src/rfu_union_tool.c index dc9782d47..51b6106d5 100644 --- a/src/rfu_union_tool.c +++ b/src/rfu_union_tool.c @@ -524,17 +524,17 @@ static void AssembleGroup(u32 group, struct RfuGameData * gname) { return; } - SpawnGroupMember(group, 0, GetUnionRoomPlayerGraphicsId(gname->playerGender, gname->unk_00.playerTrainerId[0]), gname); + SpawnGroupMember(group, 0, GetUnionRoomPlayerGraphicsId(gname->playerGender, gname->compatibility.playerTrainerId[0]), gname); } for (i = 1; i < 5; i++) { - if (gname->child_sprite_gender[i - 1] == 0) + if (gname->partnerInfo[i - 1] == 0) { DespawnGroupMember(group, i); } else if (IsUnionRoomPlayerFacingTileAt(group, i, x, y) == FALSE && IsUnionRoomPlayerFacingTileAt(group, i, x2, y2) == FALSE) { - SpawnGroupMember(group, i, GetUnionRoomPlayerGraphicsId((gname->child_sprite_gender[i - 1] >> 3) & 1, gname->child_sprite_gender[i - 1] & 7), gname); + SpawnGroupMember(group, i, GetUnionRoomPlayerGraphicsId((gname->partnerInfo[i - 1] >> 3) & 1, gname->partnerInfo[i - 1] & 7), gname); } } } @@ -546,7 +546,7 @@ static void SpawnGroupLeaderAndMembers(u32 group, struct RfuGameData * gname) { case 0x40: case 0x54: - SpawnGroupLeader(group, gname->playerGender, gname->unk_00.playerTrainerId[0]); + SpawnGroupLeader(group, gname->playerGender, gname->compatibility.playerTrainerId[0]); for (i = 0; i < 5; i++) { DespawnGroupMember(group, i); diff --git a/src/trade.c b/src/trade.c index 9687bc988..e8ada5673 100644 --- a/src/trade.c +++ b/src/trade.c @@ -759,7 +759,7 @@ static void CB2_ReturnFromLinkTrade2(void) { SetWirelessCommType1(); OpenLink(); - LinkRfu_CreateIdleTask(); + CreateTask_RfuIdle(); } else { @@ -802,13 +802,13 @@ static void CB2_ReturnFromLinkTrade2(void) case 4: if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE) { - LinkRfu_DestroyIdleTask(); + DestroyTask_RfuIdle(); CalculatePlayerPartyCount(); gMain.state++; sTradeMenuResourcesPtr->loadUISpritesState = 0; if (gWirelessCommType) { - ToggleLMANlinkRecovery(TRUE); + Rfu_SetLinkRecovery(TRUE); SetLinkStandbyCallback(); } } @@ -2019,7 +2019,7 @@ static void TradeMenuCB_12(void) static void TradeMenuCB_16(void) { - if (!ToggleLMANlinkRecovery(FALSE)) + if (!Rfu_SetLinkRecovery(FALSE)) { SetLinkStandbyCallback(); sTradeMenuResourcesPtr->tradeMenuCBnum = 13; diff --git a/src/union_room.c b/src/union_room.c index 5369225de..c4c7e7a27 100644 --- a/src/union_room.c +++ b/src/union_room.c @@ -646,12 +646,12 @@ static const u8 sUnref_84570D1[] = _("{DYNAMIC 00}·{DYNAMIC 01}"); #define IntlConvPartnerUname7(dest, arg1) ({ \ StringCopy_PlayerName(dest, (arg1).gname_uname.uname); \ - ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \ + ConvertInternationalString(dest, (arg1).gname_uname.gname.compatibility.language); \ }) #define IntlConvPartnerUname(dest, arg1) ({ \ StringCopy(dest, (arg1).gname_uname.uname); \ - ConvertInternationalString(dest, (arg1).gname_uname.gname.unk_00.language); \ + ConvertInternationalString(dest, (arg1).gname_uname.gname.compatibility.language); \ }) #define CopyTrainerCardData(dest, src, _version) ({ \ @@ -744,7 +744,7 @@ static void Task_TryBecomeLinkLeader(u8 taskId) case 0: sPlayerCurrActivity = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004]; sPlayerActivityGroupSize = sLinkGroupToActivityAndCapacity[gSpecialVar_0x8004] >> 8; - SetHostRFUtgtGname(sPlayerCurrActivity, 0, 0); + SetHostRfuGameData(sPlayerCurrActivity, 0, 0); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_LinkLeader(sPlayerActivityGroupSize & 0xF); @@ -819,19 +819,19 @@ static void Task_TryBecomeLinkLeader(u8 taskId) if ((sPlayerActivityGroupSize >> 4) != 0 && data->playerCount > (sPlayerActivityGroupSize >> 4) - 1 && (sPlayerActivityGroupSize & 0xF) != 0 - && sub_80FC1CC() + && IsRfuCommunicatingWithAllChildren() && JOY_NEW(START_BUTTON)) { data->state = 15; LinkRfu_StopManagerAndFinalizeSlots(); } - if (data->state == 6 && sub_80FA5D4()) + if (data->state == 6 && RfuTryDisconnectLeavingChildren()) { data->state = 9; } break; case 9: - if (!sub_80FA5D4()) + if (!RfuTryDisconnectLeavingChildren()) { data->state = 6; data->playerCount = UnionRoomLeaderField0CompactionAndCount(data->field_0); @@ -861,21 +861,21 @@ static void Task_TryBecomeLinkLeader(u8 taskId) } break; case 11: - switch (UnionRoomHandleYesNo(&data->textState, CheckTrainerHasLeftByIdAndName( - ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), + switch (UnionRoomHandleYesNo(&data->textState, HasTrainerLeftPartnersList( + ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname))) { case 0: LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); data->field_19 = 5; - SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + SendRfuStatusToPartner(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 12; break; case 1: case -1: data->field_19 = 6; - SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + SendRfuStatusToPartner(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 12; break; case -3: @@ -884,7 +884,7 @@ static void Task_TryBecomeLinkLeader(u8 taskId) } break; case 12: - val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + val = WaitSendRfuStatusToPartner(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); if (val == 1) { // Xfer complete @@ -918,7 +918,7 @@ static void Task_TryBecomeLinkLeader(u8 taskId) else { // Sent "no" - RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId)); + RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId)); data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); @@ -1287,7 +1287,7 @@ static void Task_TryJoinLinkGroup(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, 0); + SetHostRfuGameData(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, 0); sPlayerCurrActivity = sLinkGroupToURoomActivity[gSpecialVar_0x8004]; SetWirelessCommType1(); OpenLink(); @@ -1343,7 +1343,7 @@ static void Task_TryJoinLinkGroup(u8 taskId) u32 unusedVar; unusedVar = data->field_0->arr[id].gname_uname.gname.activity; - if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started) + if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.startedActivity) { u32 var = IsTryingToTradeWithHoennTooSoon(data, id); if (var == 0) @@ -1536,11 +1536,11 @@ static u32 IsTryingToTradeWithHoennTooSoon(struct UnkStruct_Group * arg0, s32 id { struct UnkStruct_x20 * structPtr = &arg0->field_0->arr[id]; - if (sPlayerCurrActivity == ACTIVITY_TRADE && structPtr->gname_uname.gname.unk_00.version != VERSION_FIRE_RED && structPtr->gname_uname.gname.unk_00.version != VERSION_LEAF_GREEN) + if (sPlayerCurrActivity == ACTIVITY_TRADE && structPtr->gname_uname.gname.compatibility.version != VERSION_FIRE_RED && structPtr->gname_uname.gname.compatibility.version != VERSION_LEAF_GREEN) { if (!(gSaveBlock2Ptr->specialSaveWarpFlags & CHAMPION_SAVEWARP)) return 1; - else if (structPtr->gname_uname.gname.unk_00.isChampion) + else if (structPtr->gname_uname.gname.compatibility.isChampion) return 0; } else @@ -1558,8 +1558,8 @@ static void AskToJoinRfuGroup(struct UnkStruct_Group * data, s32 id) CreateWirelessStatusIndicatorSprite(0, 0); RedrawListMenu(data->listTaskId); IntlConvPartnerUname7(gStringVar1, data->field_0->arr[data->leaderId]); - UpdateGameDataWithActivitySpriteGendersFlag(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, TRUE); - CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId)); + UpdateGameData_SetActivity(sLinkGroupToURoomActivity[gSpecialVar_0x8004], 0, TRUE); + CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.compatibility.playerTrainerId)); } u8 CreateTask_ListenToWireless(void) @@ -1585,11 +1585,11 @@ static void Task_ListenToWireless(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(0, 0, 0); + SetHostRfuGameData(0, 0, 0); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_JoinGroup(); - sub_80FB128(TRUE); + RfuSetIgnoreError(TRUE); data->field_4 = AllocZeroed(4 * sizeof(struct UnkStruct_x1C)); data->field_0 = AllocZeroed(16 * sizeof(struct UnkStruct_x20)); data->state = 2; @@ -1649,7 +1649,7 @@ static u8 URoomGroupListGetTextColor(struct UnkStruct_Group * data, u32 id) { if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { - if (data->field_0->arr[id].gname_uname.gname.started) + if (data->field_0->arr[id].gname_uname.gname.startedActivity) return UR_COLOR_WHT_WHT_LTE; else if (data->field_0->arr[id].field_1A_1) return UR_COLOR_RED_WHT_LTR; @@ -1976,7 +1976,7 @@ static void Task_StartActivity(u8 taskId) else { LinkRfu_StopManagerBeforeEnteringChat(); - SetHostRFUtgtGname(ACTIVITY_CHAT | IN_UNION_ROOM, 0, 1); + SetHostRfuGameData(ACTIVITY_CHAT | IN_UNION_ROOM, 0, 1); } EnterUnionRoomChat(); break; @@ -2076,8 +2076,8 @@ static void Task_MEvent_Leader(u8 taskId) case 0: sPlayerCurrActivity = data->activity; sPlayerActivityGroupSize = 2; - SetHostRFUtgtGname(data->activity, 0, 0); - SetGnameBufferWonderFlags(FALSE, FALSE); + SetHostRfuGameData(data->activity, 0, 0); + SetHostRfuWonderFlags(FALSE, FALSE); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_LinkLeader(2); @@ -2145,19 +2145,19 @@ static void Task_MEvent_Leader(u8 taskId) data->field_0->arr[data->playerCount].field_1B = 0; RedrawListMenu(data->listTaskId); data->field_19 = 5; - SendByteToPartnerByIdAndName(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + SendRfuStatusToPartner(5, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 8; break; case 1: case -1: data->field_19 = 6; - SendByteToPartnerByIdAndName(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + SendRfuStatusToPartner(6, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); data->state = 8; break; } break; case 8: - val = WaitSendByteToPartnerByIdAndName(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); + val = WaitSendRfuStatusToPartner(ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId), data->field_0->arr[data->playerCount].gname_uname.uname); if (val == 1) { if (data->field_19 == 5) @@ -2172,7 +2172,7 @@ static void Task_MEvent_Leader(u8 taskId) } else { - RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.unk_00.playerTrainerId)); + RequestDisconnectSlotByTrainerNameAndId(data->field_0->arr[data->playerCount].gname_uname.uname, ReadAsU16(data->field_0->arr[data->playerCount].gname_uname.gname.compatibility.playerTrainerId)); data->field_0->arr[data->playerCount].groupScheduledAnim = UNION_ROOM_SPAWN_NONE; UnionRoomLeaderField0CompactionAndCount(data->field_0); RedrawListMenu(data->listTaskId); @@ -2283,7 +2283,7 @@ static void Task_CardOrNewsWithFriend(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(data->cardOrNews + ACTIVITY_WCARD2, 0, 0); + SetHostRfuGameData(data->cardOrNews + ACTIVITY_WCARD2, 0, 0); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_JoinGroup(); @@ -2338,14 +2338,14 @@ static void Task_CardOrNewsWithFriend(u8 taskId) u32 unusedVar; unusedVar = data->field_0->arr[id].gname_uname.gname.activity; - if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.started) + if (data->field_0->arr[id].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[id].gname_uname.gname.startedActivity) { data->leaderId = id; LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); RedrawListMenu(data->listTaskId); IntlConvPartnerUname(gStringVar1, data->field_0->arr[data->leaderId]); - CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.unk_00.playerTrainerId)); + CreateTask_RfuReconnectWithParent(data->field_0->arr[data->leaderId].gname_uname.uname, ReadAsU16(data->field_0->arr[data->leaderId].gname_uname.gname.compatibility.playerTrainerId)); PlaySE(SE_POKENAV_ON); data->state = 4; } @@ -2449,7 +2449,7 @@ static void Task_CardOrNewsOverWireless(u8 taskId) switch (data->state) { case 0: - SetHostRFUtgtGname(0, 0, 0); + SetHostRfuGameData(0, 0, 0); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_JoinGroup(); @@ -2498,7 +2498,7 @@ static void Task_CardOrNewsOverWireless(u8 taskId) id = ListMenu_ProcessInput(data->listTaskId); if (data->refreshTimer > 120) { - if (data->field_0->arr[0].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[0].gname_uname.gname.started) + if (data->field_0->arr[0].groupScheduledAnim == UNION_ROOM_SPAWN_IN && !data->field_0->arr[0].gname_uname.gname.startedActivity) { if (GetGnameWonderFlagByLinkGroup(&data->field_0->arr[0].gname_uname.gname, data->cardOrNews + LINK_GROUP_WONDER_CARD)) { @@ -2506,7 +2506,7 @@ static void Task_CardOrNewsOverWireless(u8 taskId) data->refreshTimer = 0; LoadWirelessStatusIndicatorSpriteGfx(); CreateWirelessStatusIndicatorSprite(0, 0); - CreateTask_RfuReconnectWithParent(data->field_0->arr[0].gname_uname.uname, ReadAsU16(data->field_0->arr[0].gname_uname.gname.unk_00.playerTrainerId)); + CreateTask_RfuReconnectWithParent(data->field_0->arr[0].gname_uname.uname, ReadAsU16(data->field_0->arr[0].gname_uname.gname.compatibility.playerTrainerId)); PlaySE(SE_POKENAV_ON); data->state = 4; } @@ -2608,7 +2608,7 @@ void UnionRoomSpecial(void) { struct UnkStruct_URoom * dataPtr; - ClearAndInitHostRFUtgtGname(); + ResetHostRfuGameData(); CreateTask(Task_RunUnionRoom, 10); // dumb line needed to match @@ -2689,8 +2689,8 @@ static void Task_RunUnionRoom(u8 taskId) data->state = 2; break; case 2: - SetHostRFUtgtGname(IN_UNION_ROOM, 0, 0); - RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + SetHostRfuGameData(IN_UNION_ROOM, 0, 0); + SetTradeBoardRegisteredMonInfo(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_EnterUnionRoom(); @@ -2709,11 +2709,11 @@ static void Task_RunUnionRoom(u8 taskId) switch (sUnionRoomTrade.field_0) { case 1: - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); if (id >= PARTY_SIZE) { ResetUnionRoomTrade(&sUnionRoomTrade); - RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + SetTradeBoardRegisteredMonInfo(0, 0, 0); UnionRoom_ScheduleFieldMessageAndExit(gText_UR_RegistrationCanceled); } else if (!RegisterTradeMonAndGetIsEgg(GetCursorSelectionMonId(), &sUnionRoomTrade)) @@ -2734,7 +2734,7 @@ static void Task_RunUnionRoom(u8 taskId) } else { - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM; RegisterTradeMon(GetCursorSelectionMonId(), &sUnionRoomTrade); data->state = 51; @@ -2753,7 +2753,7 @@ static void Task_RunUnionRoom(u8 taskId) { if (gSpecialVar_Result == 9) { - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); PlaySE(SE_PC_LOGIN); StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); data->state = 42; @@ -2761,7 +2761,7 @@ static void Task_RunUnionRoom(u8 taskId) } else if (gSpecialVar_Result == 11) { - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); data->state = 23; gSpecialVar_Result = 0; } @@ -2786,7 +2786,7 @@ static void Task_RunUnionRoom(u8 taskId) } else if (PlayerIsTalkingToUnionRoomAide()) { - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); PlaySE(SE_PC_LOGIN); UR_EnableScriptContext2AndFreezeObjectEvents(); StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); @@ -2805,8 +2805,8 @@ static void Task_RunUnionRoom(u8 taskId) case 4: data->state = 11; UR_EnableScriptContext2AndFreezeObjectEvents(); - RfuUpdatePlayerGnameStateAndSend(0, 0, 0); - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_NPCTALK | IN_UNION_ROOM, GetActivePartnerSpriteGenderParam(data), FALSE); + SetTradeBoardRegisteredMonInfo(0, 0, 0); + UpdateGameData_SetActivity(ACTIVITY_NPCTALK | IN_UNION_ROOM, GetActivePartnerSpriteGenderParam(data), FALSE); break; } HandleUnionRoomPlayerRefresh(data); @@ -2815,21 +2815,21 @@ static void Task_RunUnionRoom(u8 taskId) case 23: if (!FuncIsActiveTask(Task_StartMenuHandleInput)) { - UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE); + UpdateGameData_SetActivity(IN_UNION_ROOM, 0, FALSE); data->state = 4; } break; case 24: UR_RunTextPrinters_CheckPrinter0Active(); playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); switch (UnionRoomGetPlayerInteractionResponse(data->field_0, taskData[0], taskData[1], playerGender)) { case 0: data->state = 26; break; case 1: - sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); + TryConnectToUnionRoomParent(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); data->field_12 = id; // Should be just 0, but won't match any other way. data->state = 25; break; @@ -3014,8 +3014,8 @@ static void Task_RunUnionRoom(u8 taskId) case 0: CopyBgTilemapBufferToVram(0); sPlayerCurrActivity = ACTIVITY_CHAT | IN_UNION_ROOM; - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_CHAT | IN_UNION_ROOM, 0, TRUE); - sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); + UpdateGameData_SetActivity(ACTIVITY_CHAT | IN_UNION_ROOM, 0, TRUE); + TryConnectToUnionRoomParent(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, sPlayerCurrActivity); data->field_12 = taskData[1]; data->state = 20; taskData[3] = 0; @@ -3044,7 +3044,7 @@ static void Task_RunUnionRoom(u8 taskId) case 1: case 2: playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); if (IsUnionRoomListenTaskActive() == TRUE) UnionRoom_ScheduleFieldMessageAndExit(gTexts_UR_ChatDeclined[playerGender]); else @@ -3060,7 +3060,7 @@ static void Task_RunUnionRoom(u8 taskId) if (RfuHasErrored()) { playerGender = GetUnionRoomPlayerGender(taskData[1], data->field_0); - UpdateGameDataWithActivitySpriteGendersFlag(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); + UpdateGameData_SetActivity(ACTIVITY_PLYRTALK | IN_UNION_ROOM, 0, TRUE); if (IsUnionRoomListenTaskActive() == TRUE) UnionRoom_ScheduleFieldMessageAndExit(gTexts_UR_ChatDeclined[playerGender]); else @@ -3071,7 +3071,7 @@ static void Task_RunUnionRoom(u8 taskId) break; case 11: PlaySE(SE_DING_DONG); - sub_80F8FA0(); + StopUnionRoomLinkManager(); data->state = 12; data->recvActivityRequest[0] = 0; break; @@ -3107,7 +3107,7 @@ static void Task_RunUnionRoom(u8 taskId) ReceiveUnionRoomActivityPacket(data); if (UnionRoom_HandleContactFromOtherPlayer(data) && JOY_NEW(B_BUTTON)) { - sub_80FBD6C(1); + Rfu_DisconnectPlayerById(1); StringCopy(gStringVar4, gText_UR_ChatEnded); data->state = 36; } @@ -3122,9 +3122,9 @@ static void Task_RunUnionRoom(u8 taskId) case 0: data->playerSendBuffer[0] = ACTIVITY_ACCEPT | IN_UNION_ROOM; if (sPlayerCurrActivity == (ACTIVITY_CHAT | IN_UNION_ROOM)) - UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), FALSE); + UpdateGameData_SetActivity(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), FALSE); else - UpdateGameDataWithActivitySpriteGendersFlag(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), TRUE); + UpdateGameData_SetActivity(sPlayerCurrActivity | IN_UNION_ROOM, GetSinglePartnerSpriteGenderParam(1), TRUE); data->field_8->arr[0].field_1B = 0; taskData[3] = 0; @@ -3218,20 +3218,20 @@ static void Task_RunUnionRoom(u8 taskId) } break; case 42: - if (GetHostRFUtgtGname()->species == SPECIES_NONE) + if (GetHostRfuGameData()->tradeSpecies == SPECIES_NONE) { data->state = 43; } else { - if (GetHostRFUtgtGname()->species == SPECIES_EGG) + if (GetHostRfuGameData()->tradeSpecies == SPECIES_EGG) { StringCopy(gStringVar4, gText_UR_CancelRegistrationOfEgg); } else { - StringCopy(gStringVar1, gSpeciesNames[GetHostRFUtgtGname()->species]); - ConvertIntToDecimalStringN(gStringVar2, GetHostRFUtgtGname()->level, STR_CONV_MODE_LEFT_ALIGN, 3); + StringCopy(gStringVar1, gSpeciesNames[GetHostRfuGameData()->tradeSpecies]); + ConvertIntToDecimalStringN(gStringVar2, GetHostRfuGameData()->tradeLevel, STR_CONV_MODE_LEFT_ALIGN, 3); StringExpandPlaceholders(gStringVar4, gText_UR_CancelRegistrationOfMon); } UnionRoom_ScheduleFieldMessageWithFollowupState(44, gStringVar4); @@ -3286,7 +3286,7 @@ static void Task_RunUnionRoom(u8 taskId) case -2: case 18: ResetUnionRoomTrade(&sUnionRoomTrade); - RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + SetTradeBoardRegisteredMonInfo(0, 0, 0); UnionRoom_ScheduleFieldMessageAndExit(gText_UR_RegistrationCanceled); break; default: @@ -3297,7 +3297,7 @@ static void Task_RunUnionRoom(u8 taskId) } break; case 55: - RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + SetTradeBoardRegisteredMonInfo(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); UnionRoom_ScheduleFieldMessageAndExit(gText_UR_RegistraionCompleted); break; case 44: @@ -3316,7 +3316,7 @@ static void Task_RunUnionRoom(u8 taskId) case 56: if (PrintOnTextbox(&data->textState, gText_UR_RegistrationCanceled2)) { - RfuUpdatePlayerGnameStateAndSend(0, 0, 0); + SetTradeBoardRegisteredMonInfo(0, 0, 0); ResetUnionRoomTrade(&sUnionRoomTrade); HandleCancelTrade(TRUE); data->state = 4; @@ -3343,7 +3343,7 @@ static void Task_RunUnionRoom(u8 taskId) data->state = 4; break; default: - switch (IsRequestedTypeAndSpeciesInPlayerParty(data->field_0->arr[var5].gname_uname.gname.type, data->field_0->arr[var5].gname_uname.gname.species)) + switch (IsRequestedTypeAndSpeciesInPlayerParty(data->field_0->arr[var5].gname_uname.gname.tradeType, data->field_0->arr[var5].gname_uname.gname.tradeSpecies)) { case UR_TRADE_MATCH: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); @@ -3352,12 +3352,12 @@ static void Task_RunUnionRoom(u8 taskId) break; case UR_TRADE_NOTYPE: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); - StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]); + StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.tradeType]); UnionRoom_ScheduleFieldMessageWithFollowupState(46, gText_UR_DontHaveTypeTrainerWants); break; case UR_TRADE_NOEGG: IntlConvPartnerUname(gStringVar1, data->field_0->arr[var5]); - StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.type]); + StringCopy(gStringVar2, gTypeNames[data->field_0->arr[var5].gname_uname.gname.tradeType]); UnionRoom_ScheduleFieldMessageWithFollowupState(46, gText_UR_DontHaveEggTrainerWants); break; } @@ -3382,9 +3382,9 @@ static void Task_RunUnionRoom(u8 taskId) if (PrintOnTextbox(&data->textState, gText_UR_WhichMonWillYouOffer)) { sUnionRoomTrade.field_0 = 2; - memcpy(&gPartnerTgtGnameSub, &data->field_0->arr[taskData[1]].gname_uname.gname.unk_00, sizeof(gPartnerTgtGnameSub)); - gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].gname_uname.gname.type; - gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].gname_uname.gname.species; + memcpy(&gPartnerTgtGnameSub, &data->field_0->arr[taskData[1]].gname_uname.gname.compatibility, sizeof(gPartnerTgtGnameSub)); + gUnionRoomRequestedMonType = data->field_0->arr[taskData[1]].gname_uname.gname.tradeType; + gUnionRoomOfferedSpecies = data->field_0->arr[taskData[1]].gname_uname.gname.tradeSpecies; gFieldCallback = FieldCB_ContinueScriptUnionRoom; ChooseMonForTradingBoard(PARTY_MENU_TYPE_UNION_ROOM_TRADE, CB2_ReturnToField); BackUpURoomField0ToDecompressionBuffer(data); @@ -3393,7 +3393,7 @@ static void Task_RunUnionRoom(u8 taskId) break; case 51: sPlayerCurrActivity = ACTIVITY_TRADE | IN_UNION_ROOM; - sub_80FC114(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, ACTIVITY_TRADE | IN_UNION_ROOM); + TryConnectToUnionRoomParent(data->field_0->arr[taskData[1]].gname_uname.uname, &data->field_0->arr[taskData[1]].gname_uname.gname, ACTIVITY_TRADE | IN_UNION_ROOM); IntlConvPartnerUname(gStringVar1, data->field_0->arr[taskData[1]]); UR_PrintFieldMessage(gTexts_UR_CommunicatingWait[2]); data->state = 25; @@ -3488,11 +3488,11 @@ static void Task_InitUnionRoom(u8 taskId) structPtr->state = 1; break; case 1: - SetHostRFUtgtGname(ACTIVITY_SEARCH, 0, 0); + SetHostRfuGameData(ACTIVITY_SEARCH, 0, 0); SetWirelessCommType1(); OpenLink(); InitializeRfuLinkManager_EnterUnionRoom(); - sub_80FB128(TRUE); + RfuSetIgnoreError(TRUE); structPtr->state = 2; break; case 2: @@ -3519,7 +3519,7 @@ static void Task_InitUnionRoom(u8 taskId) if (structPtr->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN) { IntlConvPartnerUname(text, structPtr->field_0->arr[i]); - if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].gname_uname.gname.unk_00.playerTrainerId), text)) + if (PlayerHasMetTrainerBefore(ReadAsU16(structPtr->field_0->arr[i].gname_uname.gname.compatibility.playerTrainerId), text)) { StringCopy(sUnionRoomPlayerName, text); break; @@ -3659,7 +3659,7 @@ static void Task_SearchForChildOrParent(u8 taskId) { gname_uname = sUnionGnameUnamePair_Dummy; } - if (gname_uname.gname.unk_00.language == LANGUAGE_JAPANESE) + if (gname_uname.gname.compatibility.language == LANGUAGE_JAPANESE) { gname_uname = sUnionGnameUnamePair_Dummy; } @@ -3720,7 +3720,7 @@ static bool32 GetGnameWonderFlagByLinkGroup(struct RfuGameData * gname, s16 link { if (linkGroup == LINK_GROUP_WONDER_CARD) { - if (!gname->unk_00.hasCard) + if (!gname->compatibility.hasCard) { return FALSE; } @@ -3731,7 +3731,7 @@ static bool32 GetGnameWonderFlagByLinkGroup(struct RfuGameData * gname, s16 link } else if (linkGroup == LINK_GROUP_WONDER_NEWS) { - if (!gname->unk_00.hasNews) + if (!gname->compatibility.hasNews) { return FALSE; } @@ -4078,7 +4078,7 @@ static bool8 AreGnameUnameDifferent(struct UnionGnameUnamePair * left, const str for (i = 0; i < 2; i++) { - if (left->gname.unk_00.playerTrainerId[i] != right->gname.unk_00.playerTrainerId[i]) + if (left->gname.compatibility.playerTrainerId[i] != right->gname.compatibility.playerTrainerId[i]) { return TRUE; } @@ -4100,32 +4100,22 @@ static bool32 AreUnionRoomPlayerGnamesDifferent(struct UnionGnameUnamePair * lef s32 i; if (left->gname.activity != right->gname.activity) - { return TRUE; - } - if (left->gname.started != right->gname.started) - { + if (left->gname.startedActivity != right->gname.startedActivity) return TRUE; - } for (i = 0; i < RFU_CHILD_MAX; i++) { - if (left->gname.child_sprite_gender[i] != right->gname.child_sprite_gender[i]) - { + if (left->gname.partnerInfo[i] != right->gname.partnerInfo[i]) return TRUE; - } } - if (left->gname.species != right->gname.species) - { + if (left->gname.tradeSpecies != right->gname.tradeSpecies) return TRUE; - } - if (left->gname.type != right->gname.type) - { + if (left->gname.tradeType != right->gname.tradeType) return TRUE; - } return FALSE; } @@ -4185,7 +4175,7 @@ static void PrintUnionRoomGroupOnWindow(u8 windowId, u8 x, u8 y, struct UnkStruc { IntlConvPartnerUname(uname, *group); UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx); - ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); + ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.compatibility.playerTrainerId[0] | (group->gname_uname.gname.compatibility.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); StringCopy(gStringVar4, gText_UR_ID); StringAppend(gStringVar4, id_str); x += 77; @@ -4202,7 +4192,7 @@ static void PrintGroupMemberCandidateOnWindowWithColor(u8 windowId, u8 x, u8 y, { IntlConvPartnerUname(uname, *group); UR_AddTextPrinterParameterized(windowId, 2, uname, x, y, colorIdx); - ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.unk_00.playerTrainerId[0] | (group->gname_uname.gname.unk_00.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); + ConvertIntToDecimalStringN(id_str, group->gname_uname.gname.compatibility.playerTrainerId[0] | (group->gname_uname.gname.compatibility.playerTrainerId[1] << 8), STR_CONV_MODE_LEADING_ZEROS, 5); StringCopy(gStringVar4, gText_UR_ID); StringAppend(gStringVar4, id_str); x += 71; @@ -4250,7 +4240,7 @@ static u32 ConvPartnerUnameAndGetWhetherMetAlready(struct UnkStruct_x20 * x20) { u8 sp0[30]; IntlConvPartnerUname(sp0, *x20); - return PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), sp0); + return PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.compatibility.playerTrainerId), sp0); } static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, u8 overrideGender, u8 playerIdx, u32 playerGender) @@ -4259,10 +4249,10 @@ static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, struct UnkStruct_x20 * x20 = &main0->arr[playerIdx]; - if (!x20->gname_uname.gname.started && overrideGender == 0) + if (!x20->gname_uname.gname.startedActivity && overrideGender == 0) { IntlConvPartnerUname(gStringVar1, *x20); - metBefore = PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.unk_00.playerTrainerId), gStringVar1); + metBefore = PlayerHasMetTrainerBefore(ReadAsU16(x20->gname_uname.gname.compatibility.playerTrainerId), gStringVar1); if (x20->gname_uname.gname.activity == (ACTIVITY_CHAT | IN_UNION_ROOM)) { StringExpandPlaceholders(gStringVar4, gTexts_UR_JoinChat[metBefore][playerGender]); @@ -4279,7 +4269,7 @@ static s32 UnionRoomGetPlayerInteractionResponse(struct UnkStruct_Main0 * main0, IntlConvPartnerUname(gStringVar1, *x20); if (overrideGender != 0) { - playerGender = (x20->gname_uname.gname.unk_00.playerTrainerId[overrideGender + 1] >> 3) & 1; + playerGender = (x20->gname_uname.gname.compatibility.playerTrainerId[overrideGender + 1] >> 3) & 1; } switch (x20->gname_uname.gname.activity & 0x3F) { @@ -4310,9 +4300,9 @@ static void nullsub_92(u8 windowId, u32 itemId, u8 y) static void TradeBoardPrintItemInfo(u8 windowId, u8 y, struct RfuGameData * gname, const u8 * uname, u8 colorIdx) { u8 level_t[4]; - u16 species = gname->species; - u8 type = gname->type; - u8 level = gname->level; + u16 species = gname->tradeSpecies; + u8 type = gname->tradeType; + u8 level = gname->tradeLevel; UR_AddTextPrinterParameterized(windowId, 2, uname, 8, y, colorIdx); if (species == SPECIES_EGG) @@ -4337,8 +4327,8 @@ static void TradeBoardListMenuItemPrintFunc(u8 windowId, u32 itemId, u8 y) if (itemId == -3 && y == sTradeBoardListMenuTemplate.upText_Y) { - rfu = GetHostRFUtgtGname(); - if (rfu->species != SPECIES_NONE) + rfu = GetHostRfuGameData(); + if (rfu->tradeSpecies != SPECIES_NONE) { TradeBoardPrintItemInfo(windowId, y, rfu, gSaveBlock2Ptr->playerName, 5); } @@ -4348,7 +4338,7 @@ static void TradeBoardListMenuItemPrintFunc(u8 windowId, u32 itemId, u8 y) j = 0; for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++) { - if (leader->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && leader->field_0->arr[i].gname_uname.gname.species != SPECIES_NONE) + if (leader->field_0->arr[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && leader->field_0->arr[i].gname_uname.gname.tradeSpecies != SPECIES_NONE) { j++; } @@ -4369,7 +4359,7 @@ static s32 GetIndexOfNthTradeBoardOffer(struct UnkStruct_x20 * x20, s32 n) for (i = 0; i < UROOM_MAX_GROUP_COUNT; i++) { - if (x20[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && x20[i].gname_uname.gname.species != SPECIES_NONE) + if (x20[i].groupScheduledAnim == UNION_ROOM_SPAWN_IN && x20[i].gname_uname.gname.tradeSpecies != SPECIES_NONE) { j++; } @@ -4641,8 +4631,8 @@ static void HandleCancelTrade(bool32 unlockObjs) sPlayerCurrActivity = 0; if (unlockObjs) { - RfuUpdatePlayerGnameStateAndSend(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); - UpdateGameDataWithActivitySpriteGendersFlag(IN_UNION_ROOM, 0, FALSE); + SetTradeBoardRegisteredMonInfo(sUnionRoomTrade.type, sUnionRoomTrade.playerSpecies, sUnionRoomTrade.playerLevel); + UpdateGameData_SetActivity(IN_UNION_ROOM, 0, FALSE); } } @@ -4670,7 +4660,7 @@ static u8 GetActivePartnerSpriteGenderParam(struct UnkStruct_URoom * uroom) if (uroom->field_C->arr[i].active) { retVal |= uroom->field_C->arr[i].gname_uname.gname.playerGender << 3; - retVal |= uroom->field_C->arr[i].gname_uname.gname.unk_00.playerTrainerId[0] & 7; + retVal |= uroom->field_C->arr[i].gname_uname.gname.compatibility.playerTrainerId[0] & 7; break; } } diff --git a/src/union_room_chat.c b/src/union_room_chat.c index 191201ec0..a2436575b 100644 --- a/src/union_room_chat.c +++ b/src/union_room_chat.c @@ -324,7 +324,7 @@ static void ChatEntryRoutine_Join(void) sWork->routineState++; // fall through case 1: - if (IsLinkTaskFinished() && !RfuHasFoundNewLeader()) + if (IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive()) { if (SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) sWork->routineState++; @@ -527,14 +527,14 @@ static void ChatEntryRoutine_AskQuitChatting(void) sWork->routineState = 3; break; case 0: - Rfu_UnionRoomChat_StopLinkManager(); + Rfu_StopPartnerSearch(); PrepareSendBuffer_Disband(sWork->sendMessageBuffer); sWork->routineState = 4; break; } break; case 4: - if (IsLinkTaskFinished() && !RfuHasFoundNewLeader() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) + if (IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) { if (sWork->multiplayerId == 0) sWork->routineState = 6; @@ -577,15 +577,15 @@ static void ChatEntryRoutine_ExitChat(void) } break; case 3: - if (IsLinkTaskFinished() && !RfuHasFoundNewLeader() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) + if (IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) sWork->routineState++; break; case 4: - if ((GetBlockReceivedStatus() & 1) && !RfuHasFoundNewLeader()) + if ((GetBlockReceivedStatus() & 1) && !Rfu_IsPlayerExchangeActive()) sWork->routineState++; break; case 5: - if (IsLinkTaskFinished() && !RfuHasFoundNewLeader()) + if (IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive()) { SetCloseLinkCallback(); sWork->exitDelayTimer = 0; @@ -620,7 +620,7 @@ static void ChatEntryRoutine_Drop(void) } break; case 1: - if (!RunDisplaySubtask(0) && IsLinkTaskFinished() && !RfuHasFoundNewLeader()) + if (!RunDisplaySubtask(0) && IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive()) { SetCloseLinkCallback(); sWork->exitDelayTimer = 0; @@ -666,7 +666,7 @@ static void ChatEntryRoutine_Disbanded(void) } break; case 2: - if (RunDisplaySubtask(0) != TRUE && IsLinkTaskFinished() && !RfuHasFoundNewLeader()) + if (RunDisplaySubtask(0) != TRUE && IsLinkTaskFinished() && !Rfu_IsPlayerExchangeActive()) { SetCloseLinkCallback(); sWork->exitDelayTimer = 0; @@ -704,7 +704,7 @@ static void ChatEntryRoutine_SendMessage(void) sWork->routineState++; // fall through case 1: - if (IsLinkTaskFinished() == TRUE && !RfuHasFoundNewLeader() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) + if (IsLinkTaskFinished() == TRUE && !Rfu_IsPlayerExchangeActive() && SendBlock(0, sWork->sendMessageBuffer, sizeof(sWork->sendMessageBuffer))) sWork->routineState++; break; case 2: @@ -1144,7 +1144,7 @@ static void PrepareSendBuffer_Leave(u8 *arg0) arg0[0] = CHAT_MESSAGE_LEAVE; StringCopy(&arg0[1], gSaveBlock2Ptr->playerName); arg0[1 + (PLAYER_NAME_LENGTH + 1)] = sWork->multiplayerId; - sub_80FB9D0(); + RfuSetNormalDisconnectMode(); } static void PrepareSendBuffer_Drop(u8 *arg0) @@ -1355,7 +1355,7 @@ static void Task_ReceiveChatMessage(u8 taskId) } tBlockReceivedStatus = GetBlockReceivedStatus(); - if (!tBlockReceivedStatus && RfuHasFoundNewLeader()) + if (!tBlockReceivedStatus && Rfu_IsPlayerExchangeActive()) return; tI = 0; @@ -1409,13 +1409,13 @@ static void Task_ReceiveChatMessage(u8 taskId) // You're the leader, and the person who left is not you if (GetLinkPlayerCount() == 2) { - Rfu_UnionRoomChat_StopLinkManager(); + Rfu_StopPartnerSearch(); sWork->exitType = CHATEXIT_LEADER_LAST; DestroyTask(taskId); return; } - sub_80FBD6C(tCurrLinkPlayer); + Rfu_DisconnectPlayerById(tCurrLinkPlayer); } tState = 3; @@ -1433,10 +1433,10 @@ static void Task_ReceiveChatMessage(u8 taskId) DestroyTask(taskId); break; case 2: - if (!RfuHasFoundNewLeader()) + if (!Rfu_IsPlayerExchangeActive()) { if (sWork->multiplayerId == 0) - sub_80FB030(sWork->linkPlayerCount); + SetUnionRoomChatPlayerData(sWork->linkPlayerCount); tState = 1; } diff --git a/src/wireless_communication_status_screen.c b/src/wireless_communication_status_screen.c index c9ebe676d..97131a768 100644 --- a/src/wireless_communication_status_screen.c +++ b/src/wireless_communication_status_screen.c @@ -366,7 +366,7 @@ static u32 CountMembersInGroup(struct UnkStruct_x20 * unk20, u32 * counts) k = 0; for (j = 0; j < RFU_CHILD_MAX; j++) { - if (unk20->gname_uname.gname.child_sprite_gender[j] != 0) k++; + if (unk20->gname_uname.gname.partnerInfo[j] != 0) k++; } k++; counts[sCountParams[i][1]] += k;