ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2024-12-27 04:04:17 +01:00
Code Issues Packages Projects Releases Wiki Activity
e0b76e98ff
pokeemerald/src/link_rfu_2.c
GriffinR b3e75138da Sync wireless improvements
2022-11-09 15:14:18 -05:00

3006 lines
85 KiB
C
Raw Blame History

#include "global.h"
#include "malloc.h"
#include "battle.h"
#include "berry_blender.h"
#include "decompress.h"
#include "event_data.h"
#include "gpu_regs.h"
#include "librfu.h"
#include "link.h"
#include "link_rfu.h"
#include "overworld.h"
#include "random.h"
#include "palette.h"
#include "union_room.h"
#include "string_util.h"
#include "task.h"
#include "text.h"
#include "save.h"
#include "mystery_gift_menu.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")];
u8 playerCount;
u8 linkPlayerIdx[RFU_CHILD_MAX];
struct LinkPlayer linkPlayers[MAX_RFU_PLAYERS];
u8 filler[92];
};
// Struct is mostly empty, presumably because usage of
// its fields was largely removed before release
struct RfuDebug
{
u8 unused0[6];
u16 recvCount;
u8 unused1[6];
vu8 unkFlag;
u8 childJoinCount;
u8 unused2[84];
u16 blockSendFailures;
u8 unused3[29];
u8 blockSendTime;
u8 unused4[88];
};
u32 gRfuAPIBuffer[RFU_API_BUFF_SIZE_RAM / 4];
struct RfuManager gRfu;
static u8 sHeldKeyCount;
static u8 sResendBlock8[CMD_LENGTH * 2];
static u16 sResendBlock16[CMD_LENGTH];
EWRAM_DATA struct RfuGameData gHostRfuGameData = {};
EWRAM_DATA u8 gHostRfuUsername[RFU_USER_NAME_LENGTH] = {};
static EWRAM_DATA INIT_PARAM sRfuReqConfig = {};
static EWRAM_DATA struct RfuDebug sRfuDebug = {};
static void ResetSendDataManager(struct RfuBlockSend *);
static void InitChildRecvBuffers(void);
static void InitParentSendData(void);
static void MSCCallback_Child(u16);
static void MSCCallback_Parent(u16);
static void UpdateBackupQueue(void);
static void Task_PlayerExchange(u8);
static void Task_PlayerExchangeUpdate(u8);
static void Task_PlayerExchangeChat(u8);
static void RfuHandleReceiveCommand(u8);
static void CallRfuFunc(void);
static void RfuPrepareSendBuffer(u16);
static void HandleBlockSend(void);
static void SendNextBlock(void);
static void SendLastBlock(void);
static u8 GetPartnerIndexByNameAndTrainerID(const u8 *, u16);
static void UpdateChildStatuses(void);
static s32 GetJoinGroupStatus(void);
static void ClearSelectedLinkPlayerIds(u16);
static void ValidateAndReceivePokemonSioInfo(void *);
static void ParentResetChildRecvMetadata(s32);
static void CB2_RfuIdle(void);
static void RfuReqDisconnectSlot(u32);
static void SendDisconnectCommand(u32, u32);
static void Task_TryConnectToUnionRoomParent(u8);
static void Debug_PrintEmpty(void);
static void Task_Idle(u8);
static const INIT_PARAM sRfuReqConfigTemplate = {
.maxMFrame = 4,
.MC_TimerCount = 32,
.availSlot_flag = 0,
.mboot_flag = 0,
.serialNo = RFU_SERIAL_GAME,
.gameName = (void *)&gHostRfuGameData,
.userName = gHostRfuUsername,
.fastSearchParent_flag = TRUE,
.linkRecovery_enable = FALSE,
.linkRecovery_period = 600,
.NI_failCounter_limit = 300
};
static const u8 sAvailSlots[] = {
[1] = AVAIL_SLOT1,
[2] = AVAIL_SLOT2,
[3] = AVAIL_SLOT3,
[4] = AVAIL_SLOT4
};
#define BLOCK_MASK(bitNum)((1 << (bitNum)) - 1)
static const u32 sAllBlocksReceived[] = {
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 sSlotToLinkPlayerTableId[] = {
0, 0, 1,
1, 2, 2,
2, 2, 3
};
// 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
};
// 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[] = {
[BLOCK_REQ_SIZE_NONE] = { gBlockSendBuffer, 200 },
[BLOCK_REQ_SIZE_200] = { gBlockSendBuffer, 200 },
[BLOCK_REQ_SIZE_100] = { gBlockSendBuffer, 100 },
[BLOCK_REQ_SIZE_220] = { gBlockSendBuffer, 220 },
[BLOCK_REQ_SIZE_40] = { gBlockSendBuffer, 40 }
};
static const u16 sAcceptedSerialNos[] = {
RFU_SERIAL_GAME,
RFU_SERIAL_WONDER_DISTRIBUTOR,
RFU_SERIAL_UNKNOWN,
RFU_SERIAL_END
};
static const char sASCII_RfuCmds[][15] = {
"RFU WAIT",
"RFU BOOT",
"RFU ERROR",
"RFU RESET",
"RFU CONFIG",
"RFU START",
"RFU SC POLL",
"RFU SP POLL",
"RFU START",
"RFU SEND ERR",
"RFU CP POLL"
};
static const char sASCII_RecoverCmds[][16] = {
" ",
"RECOVER START ",
"DISSCONECT ",
"RECOVER SUUSES",
"RECOVER FAILED"
};
// List of additional tasks to destroy (if active) when the RFU shuts down
static const TaskFunc sShutdownTasks[] = {
Task_PlayerExchange,
Task_PlayerExchangeUpdate,
Task_PlayerExchangeChat
};
static const char sASCII_PokemonSioInfo[] = "PokemonSioInfo";
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 Debug_PrintString(const void *str, u8 x, u8 y)
{
}
static void Debug_PrintNum(u16 num, u8 x, u8 y, u8 numDigits)
{
}
void ResetLinkRfuGFLayer(void)
{
s32 i;
u8 errorState = gRfu.errorState;
CpuFill16(0, &gRfu, sizeof(gRfu));
gRfu.errorState = errorState;
gRfu.parentChild = 0xFF;
if (gRfu.errorState != RFU_ERROR_STATE_IGNORE)
gRfu.errorState = RFU_ERROR_STATE_NONE;
for (i = 0; i < MAX_RFU_PLAYERS; i++)
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);
}
void InitRFU(void)
{
IntrFunc serialIntr = gIntrTable[1];
IntrFunc timerIntr = gIntrTable[2];
InitRFUAPI();
rfu_REQ_stopMode();
rfu_waitREQComplete();
REG_IME = 0;
gIntrTable[1] = serialIntr;
gIntrTable[2] = timerIntr;
REG_IME = INTR_FLAG_VBLANK;
}
void InitRFUAPI(void)
{
if (!rfu_initializeAPI((void *)gRfuAPIBuffer, sizeof(gRfuAPIBuffer), &gIntrTable[1], TRUE))
{
gLinkType = 0;
ClearSavedLinkPlayers();
RfuSetIgnoreError(FALSE);
ResetLinkRfuGFLayer();
rfu_setTimerInterrupt(3, &gIntrTable[2]);
}
}
static void Task_ParentSearchForChildren(u8 taskId)
{
UpdateChildStatuses();
switch (gRfu.state)
{
case RFUSTATE_INIT:
rfu_LMAN_initializeRFU(&sRfuReqConfig);
gRfu.state = RFUSTATE_INIT_END;
gTasks[taskId].data[1] = 1;
break;
case RFUSTATE_INIT_END:
break;
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 RFUSTATE_PARENT_CONNECT_END:
break;
case RFUSTATE_STOP_MANAGER:
rfu_LMAN_stopManager(FALSE);
gRfu.state = RFUSTATE_STOP_MANAGER_END;
break;
case RFUSTATE_STOP_MANAGER_END:
break;
case RFUSTATE_PARENT_FINALIZE:
gRfu.parentFinished = FALSE;
rfu_LMAN_setMSCCallback(MSCCallback_Parent);
InitChildRecvBuffers();
InitParentSendData();
gRfu.state = RFUSTATE_FINALIZED;
gTasks[taskId].data[1] = 8;
CreateTask(Task_PlayerExchange, 5);
DestroyTask(taskId);
break;
}
}
s32 Rfu_GetIndexOfNewestChild(u8 bits)
{
return sPlayerBitsToNewChildIdx[bits];
}
static void SetLinkPlayerIdsFromSlots(s32 baseSlots, s32 addSlots)
{
u8 i;
u8 baseId = 1;
s32 baseSlotsCopy = baseSlots;
s32 newId = 0;
if (addSlots == -1)
{
// Initialize
for (i = 0; i < RFU_CHILD_MAX; baseSlots >>= 1, i++)
{
if (baseSlots & 1)
{
gRfu.linkPlayerIdx[i] = baseId;
baseId++;
}
}
}
else
{
// Clear id for any empty slot
for (i = 0; i < RFU_CHILD_MAX; baseSlotsCopy >>= 1, i++)
{
if (!(baseSlotsCopy & 1))
gRfu.linkPlayerIdx[i] = 0;
}
// Get starting id by checking existing slots
for (baseId = RFU_CHILD_MAX; baseId != 0; baseId--)
{
for (i = 0; i < RFU_CHILD_MAX && gRfu.linkPlayerIdx[i] != baseId; i++)
;
if (i == RFU_CHILD_MAX)
newId = baseId;
}
// Set id for new slots
for (addSlots &= ~baseSlots, i = 0; i < RFU_CHILD_MAX; addSlots >>= 1, i++)
{
if (addSlots & 1)
gRfu.linkPlayerIdx[i] = newId++;
}
}
}
static void Task_ChildSearchForParent(u8 taskId)
{
switch (gRfu.state)
{
case RFUSTATE_INIT:
rfu_LMAN_initializeRFU((INIT_PARAM *)&sRfuReqConfigTemplate);
gRfu.state = RFUSTATE_INIT_END;
gTasks[taskId].data[1] = 1;
break;
case RFUSTATE_INIT_END:
break;
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 RFUSTATE_CHILD_CONNECT_END:
break;
case RFUSTATE_RECONNECTED:
gTasks[taskId].data[1] = 10;
break;
case RFUSTATE_CHILD_TRY_JOIN:
switch (GetJoinGroupStatus())
{
case RFU_STATUS_JOIN_GROUP_OK:
gRfu.state = RFUSTATE_CHILD_JOINED;
break;
case RFU_STATUS_JOIN_GROUP_NO:
case RFU_STATUS_LEAVE_GROUP:
rfu_LMAN_requestChangeAgbClockMaster();
gRfu.disconnectMode = RFU_DISCONNECT_NORMAL;
DestroyTask(taskId);
break;
}
break;
case RFUSTATE_CHILD_JOINED:
{
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.childJoinCount == 0)
{
Debug_PrintEmpty();
sRfuDebug.childJoinCount++;
}
CreateTask(Task_PlayerExchange, 5);
break;
}
}
}
static void InitChildRecvBuffers(void)
{
u8 i;
u8 acceptSlot = lman.acceptSlot_flag;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (acceptSlot & 1)
{
rfu_setRecvBuffer(TYPE_UNI, i, gRfu.childRecvBuffer[i], sizeof(gRfu.childRecvBuffer[0]));
rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, i);
}
acceptSlot >>= 1;
}
}
static void InitParentSendData(void)
{
u8 acceptSlot = lman.acceptSlot_flag;
rfu_UNI_setSendData(acceptSlot, gRfu.recvCmds, sizeof(gRfu.recvCmds));
gRfu.parentSendSlot = Rfu_GetIndexOfNewestChild(acceptSlot);
gRfu.parentSlots = acceptSlot;
SetLinkPlayerIdsFromSlots(acceptSlot, -1);
gRfu.parentChild = MODE_PARENT;
}
#define tConnectingForChat data[7]
static void Task_UnionRoomListen(u8 taskId)
{
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 (gRfu.state)
{
case RFUSTATE_INIT:
rfu_LMAN_initializeRFU(&sRfuReqConfig);
gRfu.state = RFUSTATE_INIT_END;
gTasks[taskId].data[1] = 1;
break;
case RFUSTATE_INIT_END:
break;
case RFUSTATE_UR_CONNECT:
rfu_LMAN_establishConnection(MODE_P_C_SWITCH, 0, 240, (u16 *)sAcceptedSerialNos);
rfu_LMAN_setMSCCallback(MSCCallback_Child);
gRfu.state = RFUSTATE_UR_CONNECT_END;
break;
case RFUSTATE_UR_CONNECT_END:
break;
case RFUSTATE_UR_PLAYER_EXCHANGE:
if (rfu_UNI_setSendData(1 << gRfu.childSlot, gRfu.childSendBuffer, sizeof(gRfu.childSendBuffer)) == 0)
{
gRfu.parentChild = MODE_CHILD;
DestroyTask(taskId);
if (gTasks[taskId].tConnectingForChat)
CreateTask(Task_PlayerExchangeChat, 1);
else
CreateTask(Task_PlayerExchange, 5);
}
break;
case RFUSTATE_UR_STOP_MANAGER:
rfu_LMAN_stopManager(FALSE);
gRfu.state = RFUSTATE_UR_STOP_MANAGER_END;
break;
case RFUSTATE_UR_STOP_MANAGER_END:
break;
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;
gRfu.parentChild = MODE_PARENT;
CreateTask(Task_PlayerExchange, 5);
gRfu.playerExchangeActive = TRUE;
DestroyTask(taskId);
break;
}
}
void LinkRfu_CreateConnectionAsParent(void)
{
rfu_LMAN_establishConnection(MODE_PARENT, 0, 240, (u16 *)sAcceptedSerialNos);
}
void LinkRfu_StopManagerBeforeEnteringChat(void)
{
rfu_LMAN_stopManager(FALSE);
}
// Argument is provided by the RFU and is unused.
static void MSCCallback_Child(u16 REQ_commandID)
{
s32 i;
for (i = 0; i < COMM_SLOT_LENGTH; i++)
gRfu.childSendBuffer[i] = 0;
rfu_REQ_recvData();
rfu_waitREQComplete();
if (gRfuSlotStatusUNI[gRfu.childSlot]->recv.newDataFlag)
{
gRfu.childSendCount++;
RfuRecvQueue_Enqueue(&gRfu.recvQueue, gRfu.childRecvQueue);
sRfuDebug.recvCount++;
UpdateBackupQueue();
rfu_UNI_readySendData(gRfu.childSlot);
rfu_UNI_clearRecvNewDataFlag(gRfu.childSlot);
}
rfu_LMAN_REQ_sendData(TRUE);
}
// Argument is provided by the RFU and is unused.
static void MSCCallback_Parent(u16 REQ_commandID)
{
gRfu.parentFinished = TRUE;
}
void LinkRfu_Shutdown(void)
{
u8 i;
rfu_LMAN_powerDownRFU();
if (gRfu.parentChild == MODE_PARENT)
{
// Stop parent searching for children
if (FuncIsActiveTask(Task_ParentSearchForChildren) == TRUE)
{
DestroyTask(gRfu.searchTaskId);
ResetLinkRfuGFLayer();
}
}
else if (gRfu.parentChild == MODE_CHILD)
{
// Stop child searching for parent
if (FuncIsActiveTask(Task_ChildSearchForParent) == TRUE)
{
DestroyTask(gRfu.searchTaskId);
ResetLinkRfuGFLayer();
}
}
else if (gRfu.parentChild == MODE_P_C_SWITCH)
{
// Stop parent-child switching mode (union room)
if (FuncIsActiveTask(Task_UnionRoomListen) == TRUE)
{
DestroyTask(gRfu.searchTaskId);
ResetLinkRfuGFLayer();
}
}
// Destroy additional tasks
for (i = 0; i < ARRAY_COUNT(sShutdownTasks); i++)
{
if (FuncIsActiveTask(sShutdownTasks[i]) == TRUE)
DestroyTask(FindTaskIdByFunc(sShutdownTasks[i]));
}
}
static void CreateTask_ParentSearchForChildren(void)
{
gRfu.searchTaskId = CreateTask(Task_ParentSearchForChildren, 1);
}
// If no parent ID (or if child connection not ready) can't reconnect with parent yet
static bool8 CanTryReconnectParent(void)
{
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 void CreateTask_ChildSearchForParent(void)
{
gRfu.searchTaskId = CreateTask(Task_ChildSearchForParent, 1);
}
bool8 LmanAcceptSlotFlagIsNotZero(void)
{
if (lman.acceptSlot_flag)
return TRUE;
return FALSE;
}
void LinkRfu_StopManagerAndFinalizeSlots(void)
{
gRfu.state = RFUSTATE_STOP_MANAGER;
gRfu.acceptSlot_flag = lman.acceptSlot_flag;
}
bool32 WaitRfuState(bool32 force)
{
if (gRfu.state == RFUSTATE_PARENT_FINALIZE_START || force)
{
gRfu.state = RFUSTATE_PARENT_FINALIZE;
return TRUE;
}
return FALSE;
}
void StopUnionRoomLinkManager(void)
{
gRfu.state = RFUSTATE_UR_STOP_MANAGER;
}
// Unused
static void ReadySendDataForSlots(u8 slots)
{
u8 i;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (slots & 1)
{
rfu_UNI_readySendData(i);
break;
}
slots >>= 1;
}
}
static void ReadAllPlayerRecvCmds(void)
{
s32 i, j;
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
struct RfuManager *rfu = &gRfu;
for (j = 0; j < CMD_LENGTH - 1; j++)
{
rfu->recvCmds[i][j][1] = gRecvCmds[i][j] >> 8;
rfu->recvCmds[i][j][0] = gRecvCmds[i][j];
}
}
CpuFill16(0, gRecvCmds, sizeof gRecvCmds);
}
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 (gRfu.linkRecovered)
{
bool8 backupEmpty = RfuBackupQueue_Dequeue(&gRfu.backupQueue, gRfu.childSendBuffer);
if (gRfu.backupQueue.count == 0)
gRfu.linkRecovered = FALSE;
if (backupEmpty)
return;
}
if (!gRfu.linkRecovered)
{
RfuSendQueue_Dequeue(&gRfu.sendQueue, gRfu.childSendBuffer);
RfuBackupQueue_Enqueue(&gRfu.backupQueue, gRfu.childSendBuffer);
}
}
bool32 IsRfuRecvQueueEmpty(void)
{
s32 i;
s32 j;
if (!gRfuLinkStatus->sendSlotUNIFlag)
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 RfuMain1_Parent(void)
{
if (gRfu.state < RFUSTATE_FINALIZED)
{
rfu_REQ_recvData();
rfu_waitREQComplete();
rfu_LMAN_REQ_sendData(FALSE);
}
else
{
gRfu.parentFinished = FALSE;
if ((gRfu.parentSlots & gRfuLinkStatus->connSlotFlag) == gRfu.parentSlots && (gRfu.parentSlots & gRfuLinkStatus->connSlotFlag))
{
if (!gRfu.parentMain2Failed)
{
if (gRfu.disconnectSlots)
{
RfuReqDisconnectSlot(gRfu.disconnectSlots);
gRfu.disconnectSlots = 0;
if (gRfu.disconnectMode == RFU_DISCONNECT_ERROR)
{
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_8);
RfuSetErrorParams(F_RFU_ERROR_8);
return FALSE;
}
if (!lman.acceptSlot_flag)
{
LinkRfu_Shutdown();
gReceivedRemoteLinkPlayers = 0;
return FALSE;
}
}
ReadAllPlayerRecvCmds();
rfu_UNI_readySendData(gRfu.parentSendSlot);
rfu_LMAN_REQ_sendData(TRUE);
}
else
{
rfu_REQ_PARENT_resumeRetransmitAndChange();
}
gRfu.runParentMain2 = TRUE;
}
}
return FALSE;
}
static bool32 RfuMain2_Parent(void)
{
u16 i;
u16 flags;
u8 r0;
u16 j;
bool8 failed;
if (gRfu.state >= RFUSTATE_FINALIZED && gRfu.runParentMain2 == TRUE)
{
rfu_waitREQComplete();
while (gRfu.parentFinished == FALSE)
{
if (gRfu.errorState != RFU_ERROR_STATE_NONE)
return FALSE;
}
rfu_REQ_recvData();
rfu_waitREQComplete();
if ((lman.parentAck_flag & gRfu.parentSlots) == gRfu.parentSlots)
{
gRfu.parentMain2Failed = FALSE;
sRfuDebug.recvCount++;
flags = lman.acceptSlot_flag;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (flags & 1)
{
if (gRfu.childRecvBuffer[i][1])
{
if (gRfu.childRecvIds[i] != 0xFF && (gRfu.childRecvBuffer[i][0] >> 5) != ((gRfu.childRecvIds[i] + 1) & 7))
{
if (++gRfu.numChildRecvErrors[i] > 4)
RfuSetErrorParams(F_RFU_ERROR_8 | F_RFU_ERROR_1);
}
else
{
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] = (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;
}
}
}
rfu_UNI_clearRecvNewDataFlag(i);
}
flags >>= 1;
}
MoveSendCmdToRecv();
RfuHandleReceiveCommand(0);
CallRfuFunc();
if (gRfu.nextChildBits && !gRfu.stopNewConnections)
{
sRfuDebug.unkFlag = FALSE;
rfu_clearSlot(TYPE_UNI_SEND | TYPE_UNI_RECV, gRfu.parentSendSlot);
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((gRfu.nextChildBits >> i) & 1)
rfu_setRecvBuffer(TYPE_UNI, i, gRfu.childRecvBuffer[i], sizeof(gRfu.childRecvBuffer[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
{
gRfu.parentMain2Failed = TRUE;
gRfu.runParentMain2 = FALSE;
}
gRfu.runParentMain2 = FALSE;
}
failed = gRfu.parentMain2Failed;
return gRfuLinkStatus->sendSlotUNIFlag ? failed & 1 : FALSE;
}
static void ChildBuildSendCmd(u16 *sendCmd, u8 *dst)
{
s32 i;
if (sendCmd[0])
{
sendCmd[0] |= (gRfu.childSendCmdId << 5);
gRfu.childSendCmdId = (gRfu.childSendCmdId + 1) & 7;
for (i = 0; i < CMD_LENGTH - 1; i++)
{
dst[2 * i + 1] = sendCmd[i] >> 8;
dst[2 * i + 0] = sendCmd[i];
}
}
else
{
for (i = 0; i < COMM_SLOT_LENGTH; i++)
dst[i] = 0;
}
}
static bool32 RfuMain1_Child(void)
{
u8 i;
u8 j;
u8 recv[MAX_RFU_PLAYERS * (2 * (CMD_LENGTH - 1))];
u8 send[2 * (CMD_LENGTH - 1)];
u8 status;
RfuRecvQueue_Dequeue(&gRfu.recvQueue, recv);
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
for (j = 0; j < CMD_LENGTH - 1; j++)
gRecvCmds[i][j] = (recv[i * COMM_SLOT_LENGTH + (j * 2) + 1] << 8)
| recv[i * COMM_SLOT_LENGTH + (j * 2) + 0];
}
RfuHandleReceiveCommand(0);
if (lman.childClockSlave_flag == 0 && gRfu.disconnectMode != RFU_DISCONNECT_NONE)
{
rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
rfu_waitREQComplete();
status = RfuGetStatus();
if (status != RFU_STATUS_FATAL_ERROR && status != RFU_STATUS_JOIN_GROUP_NO && status != RFU_STATUS_LEAVE_GROUP)
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_8);
rfu_clearAllSlot();
gReceivedRemoteLinkPlayers = FALSE;
gRfu.callback = NULL;
if (gRfu.disconnectMode == RFU_DISCONNECT_ERROR)
{
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;
gRfu.disconnectMode = RFU_DISCONNECT_NONE;
}
if (gRfu.childSendCount)
{
gRfu.childSendCount--;
CallRfuFunc();
ChildBuildSendCmd(gSendCmd, send);
RfuSendQueue_Enqueue(&gRfu.sendQueue, send);
for (i = 0; i < CMD_LENGTH - 1; i++)
gSendCmd[i] = 0;
}
return IsRfuRecvQueueEmpty();
}
static void HandleSendFailure(u8 unused, u32 flags)
{
s32 i, j, temp;
const u8 *payload = gRfu.sendBlock.payload;
for (i = 0; i < gRfu.sendBlock.count; i++)
{
if (!(flags & 1))
{
sResendBlock16[0] = RFUCMD_SEND_BLOCK | i;
for (j = 0; j < CMD_LENGTH - 1; j++)
{
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 < CMD_LENGTH - 1; j++)
{
temp = j * 2;
sResendBlock8[temp + 1] = sResendBlock16[j] >> 8;
sResendBlock8[temp + 0] = sResendBlock16[j];
}
RfuSendQueue_Enqueue(&gRfu.sendQueue, sResendBlock8);
gRfu.sendBlock.failedFlags |= (1 << i);
}
flags >>= 1;
}
}
void Rfu_SetBlockReceivedFlag(u8 linkPlayerId)
{
if (gRfu.parentChild == MODE_PARENT && linkPlayerId)
gRfu.numBlocksReceived[linkPlayerId] = 1;
else
gRfu.blockReceived[linkPlayerId] = TRUE;
}
void Rfu_ResetBlockReceivedFlag(u8 linkPlayerId)
{
gRfu.blockReceived[linkPlayerId] = FALSE;
gRfu.recvBlock[linkPlayerId].receiving = RECV_STATE_READY;
}
static u8 LoadLinkPlayerIds(const u8 *ids)
{
u8 i;
if (gRfu.parentChild == MODE_PARENT)
return FALSE;
for (i = 0; i < RFU_CHILD_MAX; i++)
gRfu.linkPlayerIdx[i] = ids[i];
return ids[gRfu.childSlot];
}
static void SendKeysToRfu(void)
{
if (gReceivedRemoteLinkPlayers
&& gHeldKeyCodeToSend != LINK_KEY_CODE_NULL
&& gLinkTransferringData != TRUE)
{
sHeldKeyCount++;
gHeldKeyCodeToSend |= (sHeldKeyCount << 8);
RfuPrepareSendBuffer(RFUCMD_SEND_HELD_KEYS);
}
}
struct RfuGameData *GetHostRfuGameData(void)
{
return &gHostRfuGameData;
}
bool32 IsSendingKeysToRfu(void)
{
return gRfu.callback == SendKeysToRfu;
}
void StartSendingKeysToRfu(void)
{
gRfu.callback = SendKeysToRfu;
}
void ClearLinkRfuCallback(void)
{
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;
u16 j;
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
switch (gRecvCmds[i][0] & RFUCMD_MASK)
{
case RFUCMD_SEND_PLAYER_IDS_NEW:
if (gRfu.parentChild == MODE_CHILD && gReceivedRemoteLinkPlayers)
return;
// fallthrough
case RFUCMD_SEND_PLAYER_IDS:
if (gRfuLinkStatus->parentChild == MODE_CHILD)
{
gRfu.playerCount = gRecvCmds[i][1];
gRfu.multiplayerId = LoadLinkPlayerIds((u8 *)(gRecvCmds[i] + 2));
}
break;
case RFUCMD_SEND_BLOCK_INIT:
if (gRfu.recvBlock[i].receiving == RECV_STATE_READY)
{
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:
if (gRfu.recvBlock[i].receiving == RECV_STATE_RECEIVING)
{
gRfu.recvBlock[i].next = gRecvCmds[i][0] & 0xff;
gRfu.recvBlock[i].receivedFlags |= (1 << gRfu.recvBlock[i].next);
for (j = 0; j < 6; j++)
gBlockRecvBuffer[i][gRfu.recvBlock[i].next * 6 + j] = gRecvCmds[i][j + 1];
if (gRfu.recvBlock[i].receivedFlags == sAllBlocksReceived[gRfu.recvBlock[i].count])
{
gRfu.recvBlock[i].receiving = RECV_STATE_FINISHED;
Rfu_SetBlockReceivedFlag(i);
if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && gReceivedRemoteLinkPlayers && gRfu.parentChild == MODE_CHILD)
ValidateAndReceivePokemonSioInfo(gBlockRecvBuffer);
}
}
break;
case RFUCMD_SEND_BLOCK_REQ:
Rfu_InitBlockSend(sBlockRequests[gRecvCmds[i][1]].address, (u16)sBlockRequests[gRecvCmds[i][1]].size);
break;
case RFUCMD_READY_CLOSE_LINK:
gRfu.readyCloseLink[i] = TRUE;
break;
case RFUCMD_READY_EXIT_STANDBY:
if (gRfu.allReadyNum == gRecvCmds[i][1])
gRfu.readyExitStandby[i] = TRUE;
break;
case RFUCMD_DISCONNECT:
if (gRfu.parentChild == MODE_CHILD)
{
// Disconnect child
if (gReceivedRemoteLinkPlayers)
{
if (gRecvCmds[i][1] & gRfuLinkStatus->connSlotFlag)
{
gReceivedRemoteLinkPlayers = 0;
rfu_LMAN_requestChangeAgbClockMaster();
gRfu.disconnectMode = gRecvCmds[i][2];
}
gRfu.playerCount = gRecvCmds[i][3];
ClearSelectedLinkPlayerIds(gRecvCmds[i][1]);
}
}
else
{
// Disconnect parent
RfuPrepareSendBuffer(RFUCMD_DISCONNECT_PARENT);
gSendCmd[1] = gRecvCmds[i][1];
gSendCmd[2] = gRecvCmds[i][2];
gSendCmd[3] = gRecvCmds[i][3];
}
break;
case RFUCMD_DISCONNECT_PARENT:
if (gRfu.parentChild == MODE_PARENT)
{
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 (gRfu.parentChild == MODE_PARENT && gRfu.numBlocksReceived[i])
{
if (gRfu.numBlocksReceived[i] == 4)
{
gRfu.blockReceived[i] = TRUE;
gRfu.numBlocksReceived[i] = 0;
}
else
gRfu.numBlocksReceived[i]++;
}
}
}
static bool8 AreAllPlayersReadyToReceive(void)
{
s32 i;
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
if (gRfu.recvBlock[i].receiving != RECV_STATE_READY)
return FALSE;
}
return TRUE;
}
static bool8 AreAllPlayersFinishedReceiving(void)
{
s32 i;
for (i = 0; i < gRfu.playerCount; i++)
{
if (gRfu.recvBlock[i].receiving != RECV_STATE_FINISHED || gRfu.blockReceived[i] != TRUE)
return FALSE;
}
return TRUE;
}
static void ResetSendDataManager(struct RfuBlockSend *data)
{
data->next = 0;
data->count = 0;
data->payload = NULL;
data->receivedFlags = 0;
data->sending = FALSE;
data->owner = 0;
data->receiving = RECV_STATE_READY;
}
u8 Rfu_GetBlockReceivedStatus(void)
{
u8 flags = 0;
s32 i;
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
if (gRfu.recvBlock[i].receiving == RECV_STATE_FINISHED && gRfu.blockReceived[i] == TRUE)
flags |= (1 << i);
}
return flags;
}
static void RfuPrepareSendBuffer(u16 command)
{
u8 i;
u8 *buff;
u8 tmp;
gSendCmd[0] = command;
switch (command)
{
case RFUCMD_SEND_BLOCK_INIT:
gSendCmd[1] = gRfu.sendBlock.count;
gSendCmd[2] = gRfu.sendBlock.owner + 0x80;
break;
case RFUCMD_SEND_BLOCK_REQ:
if (AreAllPlayersReadyToReceive())
gSendCmd[1] = gRfu.blockRequestType;
break;
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] = gRfu.linkPlayerIdx[i];
break;
case RFUCMD_READY_EXIT_STANDBY:
case RFUCMD_READY_CLOSE_LINK:
gSendCmd[1] = gRfu.allReadyNum;
break;
case RFUCMD_BLENDER_SEND_KEYS:
gSendCmd[0] = command;
gSendCmd[1] = gMain.heldKeys;
break;
case RFUCMD_SEND_PACKET:
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_DISCONNECT_PARENT:
case RFUCMD_DISCONNECT:
break;
}
}
void Rfu_SendPacket(void *data)
{
if (gSendCmd[0] == 0 && !RfuHasErrored())
{
memcpy(gRfu.packet, data, sizeof(gRfu.packet));
RfuPrepareSendBuffer(RFUCMD_SEND_PACKET);
}
}
bool32 Rfu_InitBlockSend(const u8 *src, size_t size)
{
bool8 r4;
if (gRfu.callback != NULL)
return FALSE;
if (gSendCmd[0] != 0)
return FALSE;
if (gRfu.sendBlock.sending)
{
sRfuDebug.blockSendTime++;
return FALSE;
}
r4 = (size % 12) != 0;
gRfu.sendBlock.owner = GetMultiplayerId();
gRfu.sendBlock.sending = TRUE;
gRfu.sendBlock.count = (size / 12) + r4;
gRfu.sendBlock.next = 0;
if (size > BLOCK_BUFFER_SIZE)
gRfu.sendBlock.payload = src;
else
{
if (src != gBlockSendBuffer)
memcpy(gBlockSendBuffer, src, size);
gRfu.sendBlock.payload = gBlockSendBuffer;
}
RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT);
gRfu.callback = HandleBlockSend;
gRfu.blockSendAttempts = 0;
return TRUE;
}
static void HandleBlockSend(void)
{
if (gSendCmd[0] == 0)
{
RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_INIT);
if (gRfu.parentChild == MODE_PARENT)
{
if (++gRfu.blockSendAttempts > 2)
gRfu.callback = SendNextBlock;
}
else
{
if ((gRecvCmds[GetMultiplayerId()][0] & RFUCMD_MASK) == RFUCMD_SEND_BLOCK_INIT)
gRfu.callback = SendNextBlock;
}
}
}
static void SendNextBlock(void)
{
s32 i;
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)
{
gRfu.sendBlock.sending = FALSE;
gRfu.callback = SendLastBlock;
}
}
static void SendLastBlock(void)
{
const u8 *src = gRfu.sendBlock.payload;
u8 mpId = GetMultiplayerId();
s32 i;
if (gRfu.parentChild == MODE_CHILD)
{
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 (gRfu.recvBlock[mpId].receivedFlags != sAllBlocksReceived[gRfu.recvBlock[mpId].count])
{
HandleSendFailure(mpId, gRfu.recvBlock[mpId].receivedFlags);
sRfuDebug.blockSendFailures++;
}
else
{
gRfu.callback = NULL;
}
}
}
else
{
gRfu.callback = NULL;
}
}
bool8 Rfu_SendBlockRequest(u8 type)
{
gRfu.blockRequestType = type;
RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ);
return TRUE;
}
static void RfuShutdownAfterDisconnect(void)
{
rfu_clearAllSlot();
rfu_LMAN_powerDownRFU();
gReceivedRemoteLinkPlayers = 0;
gRfu.isShuttingDown = TRUE;
gRfu.callback = NULL;
}
static void DisconnectRfu(void)
{
rfu_REQ_disconnect(gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag);
rfu_waitREQComplete();
RfuShutdownAfterDisconnect();
}
static void TryDisconnectRfu(void)
{
if (gRfu.parentChild == MODE_CHILD)
{
rfu_LMAN_requestChangeAgbClockMaster();
gRfu.disconnectMode = RFU_DISCONNECT_NORMAL;
}
else
{
gRfu.callback = DisconnectRfu;
}
}
void LinkRfu_FatalError(void)
{
rfu_LMAN_requestChangeAgbClockMaster();
gRfu.disconnectMode = RFU_DISCONNECT_ERROR;
gRfu.disconnectSlots = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag;
}
// RFU equivalent of LinkCB_WaitCloseLink
static void WaitAllReadyToCloseLink(void)
{
s32 i;
u8 playerCount = gRfu.playerCount;
s32 count = 0;
// Wait for all players to be ready
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
if (gRfu.readyCloseLink[i])
count++;
}
if (count == playerCount)
{
// All ready, close link
gBattleTypeFlags &= ~BATTLE_TYPE_LINK_IN_BATTLE;
if (gRfu.parentChild == MODE_CHILD)
{
gRfu.errorState = RFU_ERROR_STATE_DISCONNECTING;
TryDisconnectRfu();
}
else
{
gRfu.callback = TryDisconnectRfu;
}
}
}
static void SendReadyCloseLink(void)
{
if (gSendCmd[0] == 0 && !gRfu.playerExchangeActive)
{
RfuPrepareSendBuffer(RFUCMD_READY_CLOSE_LINK);
gRfu.callback = WaitAllReadyToCloseLink;
}
}
static void Task_TryReadyCloseLink(u8 taskId)
{
if (gRfu.callback == NULL)
{
gRfu.stopNewConnections = TRUE;
gRfu.callback = SendReadyCloseLink;
DestroyTask(taskId);
}
}
void Rfu_SetCloseLinkCallback(void)
{
if (!FuncIsActiveTask(Task_TryReadyCloseLink))
CreateTask(Task_TryReadyCloseLink, 5);
}
static void SendReadyExitStandbyUntilAllReady(void)
{
u8 playerCount;
u8 i;
if (GetMultiplayerId() != 0)
{
if (gRfu.recvQueue.count == 0 && gRfu.resendExitStandbyTimer > 60)
{
RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
gRfu.resendExitStandbyTimer = 0;
}
}
playerCount = GetLinkPlayerCount();
for (i = 0; i < playerCount; i++)
{
if (!gRfu.readyExitStandby[i])
break;
}
if (i == playerCount)
{
for (i = 0; i < MAX_RFU_PLAYERS; i++)
gRfu.readyExitStandby[i] = FALSE;
gRfu.allReadyNum++;
gRfu.callback = NULL;
}
gRfu.resendExitStandbyTimer++;
}
static void LinkLeaderReadyToExitStandby(void)
{
if (gRfu.recvQueue.count == 0 && gSendCmd[0] == 0)
{
RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
gRfu.callback = SendReadyExitStandbyUntilAllReady;
}
}
// RFU equivalent of LinkCB_Standby and LinkCB_StandbyForAll
static void Rfu_LinkStandby(void)
{
u8 i;
u8 playerCount;
if (GetMultiplayerId() != 0)
{
// Not link leader, send exit standby when ready
if (gRfu.recvQueue.count == 0 && gSendCmd[0] == 0)
{
RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
gRfu.callback = SendReadyExitStandbyUntilAllReady;
}
}
else
{
// Link leader, wait for all members to send exit ready
playerCount = GetLinkPlayerCount();
for (i = 1; i < playerCount; i++)
{
if (!gRfu.readyExitStandby[i])
break;
}
if (i == playerCount)
{
if (gRfu.recvQueue.count == 0 && gSendCmd[0] == 0)
{
RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
gRfu.callback = LinkLeaderReadyToExitStandby;
}
}
}
}
void Rfu_SetLinkStandbyCallback(void)
{
if (gRfu.callback == NULL)
{
gRfu.callback = Rfu_LinkStandby;
gRfu.resendExitStandbyTimer = 0;
}
}
bool32 IsRfuSerialNumberValid(u32 serialNo)
{
s32 i;
for (i = 0; sAcceptedSerialNos[i] != serialNo; i++)
{
if (sAcceptedSerialNos[i] == RFU_SERIAL_END)
return FALSE;
}
return TRUE;
}
u8 Rfu_SetLinkRecovery(bool32 enable)
{
if (enable == FALSE)
return rfu_LMAN_setLinkRecovery(0, 0);
rfu_LMAN_setLinkRecovery(1, 600);
return 0;
}
void Rfu_StopPartnerSearch(void)
{
gRfu.stopNewConnections = TRUE;
rfu_LMAN_stopManager(FALSE);
}
u8 Rfu_GetMultiplayerId(void)
{
if (gRfu.parentChild == MODE_PARENT)
return 0;
return gRfu.multiplayerId;
}
u8 Rfu_GetLinkPlayerCount(void)
{
return gRfu.playerCount;
}
bool8 IsLinkRfuTaskFinished(void)
{
if (gRfu.status == RFU_STATUS_CONNECTION_ERROR)
return FALSE;
return gRfu.callback ? FALSE : TRUE;
}
static void CallRfuFunc(void)
{
if (gRfu.callback)
gRfu.callback();
}
static bool8 CheckForLeavingGroupMembers(void)
{
s32 i;
bool8 memberLeft = FALSE;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
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 (gRfu.partnerRecvStatuses[i] == RFU_STATUS_LEAVE_GROUP_NOTICE)
{
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, &gRfu.partnerSendStatuses[i], 1);
memberLeft = TRUE;
}
}
else if (gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_FAILED)
rfu_clearSlot(TYPE_NI_RECV, i);
{
}
}
}
return memberLeft;
}
bool32 RfuTryDisconnectLeavingChildren(void)
{
u8 childrenLeaving = 0;
s32 i;
// Check all children, get those waiting to be disconnected
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE)
{
childrenLeaving |= (1 << i);
gRfu.partnerRecvStatuses[i] = RFU_STATUS_OK;
}
}
// Disconnect any leaving children
if (childrenLeaving)
{
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 (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE_READY
|| gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE)
return TRUE;
}
return FALSE;
}
bool32 HasTrainerLeftPartnersList(u16 trainerId, const u8 *name)
{
u8 idx = GetPartnerIndexByNameAndTrainerID(name, trainerId);
if (idx == 0xFF)
return TRUE;
if (gRfu.partnerSendStatuses[idx] == RFU_STATUS_LEAVE_GROUP)
return TRUE;
return FALSE;
}
void SendRfuStatusToPartner(u8 status, u16 trainerId, const u8 *name)
{
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)
{
gRfu.leaveGroupStatus = RFU_STATUS_LEAVE_GROUP_NOTICE;
rfu_clearSlot(TYPE_NI_SEND, gRfu.childSlot);
rfu_NI_setSendData(1 << gRfu.childSlot, 8, &gRfu.leaveGroupStatus, 1);
}
u32 WaitSendRfuStatusToPartner(u16 trainerId, const u8 *name)
{
u8 idx = GetPartnerIndexByNameAndTrainerID(name, trainerId);
if (idx == 0xFF)
return 2;
if (gRfuSlotStatusNI[idx]->send.state == 0)
return 1;
return 0;
}
static void UpdateChildStatuses(void)
{
s32 i;
CheckForLeavingGroupMembers();
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_SUCCESS
|| gRfuSlotStatusNI[i]->send.state == SLOT_STATE_SEND_FAILED)
{
if (gRfu.partnerRecvStatuses[i] == RFU_STATUS_CHILD_LEAVE_READY)
gRfu.partnerRecvStatuses[i] = RFU_STATUS_CHILD_LEAVE;
rfu_clearSlot(TYPE_NI_SEND, i);
}
}
}
static s32 GetJoinGroupStatus(void)
{
s32 status = RFU_STATUS_OK;
if (gRfu.leaveGroupStatus == RFU_STATUS_LEAVE_GROUP_NOTICE)
{
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[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, gRfu.childSlot);
RfuSetStatus(gRfu.childRecvStatus, 0);
status = gRfu.childRecvStatus;
}
else if (gRfuSlotStatusNI[gRfu.childSlot]->recv.state == SLOT_STATE_RECV_FAILED)
{
rfu_clearSlot(TYPE_NI_RECV, gRfu.childSlot);
status = RFU_STATUS_JOIN_GROUP_NO;
}
return status;
}
#define tState data[0]
static void Task_PlayerExchange(u8 taskId)
{
s32 i;
if (gRfu.status == RFU_STATUS_FATAL_ERROR || gRfu.status == RFU_STATUS_CONNECTION_ERROR)
{
gRfu.playerExchangeActive = FALSE;
DestroyTask(taskId);
}
switch (gTasks[taskId].tState)
{
case 0:
if (AreAllPlayersReadyToReceive())
{
ResetBlockReceivedFlags();
LocalLinkPlayerToBlock();
gTasks[taskId].tState++;
}
break;
case 1:
if (gRfu.parentChild == MODE_PARENT)
{
if (gReceivedRemoteLinkPlayers)
RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS_NEW);
else
RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS);
gTasks[taskId].tState = 101;
}
else
gTasks[taskId].tState = 2;
break;
case 101:
if (gSendCmd[0] == 0)
gTasks[taskId].tState = 2;
break;
case 2:
if (gRfu.playerCount)
gTasks[taskId].tState++;
break;
case 3:
if (gRfu.parentChild == MODE_PARENT)
{
if (AreAllPlayersReadyToReceive())
{
gRfu.blockRequestType = BLOCK_REQ_SIZE_NONE;
RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ);
gTasks[taskId].tState++;
}
}
else
gTasks[taskId].tState++;
break;
case 4:
if (AreAllPlayersFinishedReceiving())
gTasks[taskId].tState++;
break;
case 5:
for (i = 0; i < gRfu.playerCount; i++)
{
LinkPlayerFromBlock(i);
Rfu_ResetBlockReceivedFlag(i);
}
gTasks[taskId].tState++;
break;
case 6:
DestroyTask(taskId);
gReceivedRemoteLinkPlayers = TRUE;
gRfu.playerExchangeActive = FALSE;
rfu_LMAN_setLinkRecovery(1, 600);
if (gRfu.newChildQueue)
{
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((gRfu.newChildQueue >> i) & 1)
{
gRfu.nextChildBits = 1 << i;
gRfu.newChildQueue ^= (1 << i);
}
}
}
break;
}
}
static void ClearSelectedLinkPlayerIds(u16 selected)
{
s32 i;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((selected >> i) & 1)
gRfu.linkPlayerIdx[i] = 0;
}
}
static void ReceiveRfuLinkPlayers(const struct SioInfo *sioInfo)
{
s32 i;
gRfu.playerCount = sioInfo->playerCount;
for (i = 0; i < RFU_CHILD_MAX; i++)
gRfu.linkPlayerIdx[i] = sioInfo->linkPlayerIdx[i];
for (i = 0; i < MAX_RFU_PLAYERS; i++)
{
gLinkPlayers[i] = sioInfo->linkPlayers[i];
ConvertLinkPlayerName(gLinkPlayers + i);
}
}
static void ValidateAndReceivePokemonSioInfo(void *recvBuffer)
{
if (strcmp(sASCII_PokemonSioInfo, recvBuffer) == 0)
{
ReceiveRfuLinkPlayers(recvBuffer);
CpuFill16(0, recvBuffer, sizeof(struct SioInfo));
ResetBlockReceivedFlag(0);
}
}
// Equivalent to Task_PlayerExchange, but for when new children arrive after the first exchange
static void Task_PlayerExchangeUpdate(u8 taskId)
{
s32 i;
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)
{
gRfu.playerExchangeActive = FALSE;
DestroyTask(taskId);
}
switch (gTasks[taskId].tState)
{
case 0:
if (gSendCmd[0] == 0)
{
ResetBlockReceivedFlag(playerId);
RfuPrepareSendBuffer(RFUCMD_SEND_PLAYER_IDS_NEW);
gTasks[taskId].tState++;
}
break;
case 1:
if (gSendCmd[0] == 0)
gTasks[taskId].tState++;
break;
case 2:
if ((GetBlockReceivedStatus() >> playerId) & 1)
{
ResetBlockReceivedFlag(playerId);
playerBlock = (struct LinkPlayerBlock *)gBlockRecvBuffer[playerId];
gLinkPlayers[playerId] = playerBlock->linkPlayer;
ConvertLinkPlayerName(&gLinkPlayers[playerId]);
gTasks[taskId].tState++;
}
break;
case 3:
sio = (struct SioInfo *)gBlockSendBuffer;
memcpy(sio->magic, sASCII_PokemonSioInfo, sizeof sASCII_PokemonSioInfo);
sio->playerCount = gRfu.playerCount;
for (i = 0; i < RFU_CHILD_MAX; i++)
sio->linkPlayerIdx[i] = gRfu.linkPlayerIdx[i];
memcpy(sio->linkPlayers, gLinkPlayers, sizeof gLinkPlayers);
gTasks[taskId].tState++;
// fallthrough
case 4:
sio = (struct SioInfo *)gBlockSendBuffer;
sio->playerCount = gRfu.playerCount;
for (i = 0; i < RFU_CHILD_MAX; i++)
sio->linkPlayerIdx[i] = gRfu.linkPlayerIdx[i];
memcpy(sio->linkPlayers, gLinkPlayers, sizeof(gLinkPlayers));
if (SendBlock(0, gBlockSendBuffer, 0xa0))
gTasks[taskId].tState++;
break;
case 5:
if (IsLinkTaskFinished() && GetBlockReceivedStatus() & 1)
{
CpuFill16(0, gBlockRecvBuffer, sizeof(struct SioInfo));
ResetBlockReceivedFlag(0);
gRfu.playerExchangeActive = FALSE;
if (gRfu.newChildQueue)
{
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((gRfu.newChildQueue >> i) & 1)
{
gRfu.nextChildBits = 1 << i;
gRfu.newChildQueue ^= (1 << i);
gRfu.playerExchangeActive = TRUE;
break;
}
}
}
DestroyTask(taskId);
}
break;
}
}
// Equivalent to Task_PlayerExchange but for chatting with a Union Room partner
static void Task_PlayerExchangeChat(u8 taskId)
{
if (gRfu.status == RFU_STATUS_FATAL_ERROR || gRfu.status == RFU_STATUS_CONNECTION_ERROR)
DestroyTask(taskId);
switch (gTasks[taskId].tState)
{
case 0:
if (gRfu.playerCount)
{
LocalLinkPlayerToBlock();
SendBlock(0, gBlockSendBuffer, sizeof(struct LinkPlayerBlock));
gTasks[taskId].tState++;
}
break;
case 1:
if (IsLinkTaskFinished())
gTasks[taskId].tState++;
break;
case 2:
if (GetBlockReceivedStatus() & 1)
{
ReceiveRfuLinkPlayers((const struct SioInfo *)gBlockRecvBuffer);
ResetBlockReceivedFlag(0);
gReceivedRemoteLinkPlayers = 1;
DestroyTask(taskId);
}
break;
}
}
static void RfuCheckErrorStatus(void)
{
if (gRfu.errorState == RFU_ERROR_STATE_OCCURRED && lman.childClockSlave_flag == 0)
{
if (gMain.callback2 == CB2_MysteryGiftEReader || lman.init_param->mboot_flag)
gWirelessCommType = 2;
SetMainCallback2(CB2_LinkError);
gMain.savedCallback = CB2_LinkError;
SetLinkErrorBuffer((gRfu.errorInfo << 16) | (gRfu.errorParam0 << 8) | gRfu.errorParam1, gRfu.recvQueue.count, gRfu.sendQueue.count, RfuGetStatus() == RFU_STATUS_CONNECTION_ERROR);
gRfu.errorState = RFU_ERROR_STATE_PROCESSED;
CloseLink();
}
else if (gRfu.sendQueue.full == TRUE || gRfu.recvQueue.full == TRUE)
{
if (lman.childClockSlave_flag)
rfu_LMAN_requestChangeAgbClockMaster();
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 RfuMain1_UnionRoom(void)
{
if (lman.parent_child == MODE_PARENT)
{
rfu_REQ_recvData();
rfu_waitREQComplete();
rfu_LMAN_REQ_sendData(FALSE);
}
}
// Rfu equivalent of LinkMain1
bool32 RfuMain1(void)
{
bool32 retval = FALSE;
gRfu.parentId = 0;
rfu_LMAN_manager_entity(Random2());
if (!gRfu.isShuttingDown)
{
switch (gRfu.parentChild)
{
case MODE_PARENT:
RfuMain1_Parent();
break;
case MODE_CHILD:
retval = RfuMain1_Child();
break;
case MODE_P_C_SWITCH:
RfuMain1_UnionRoom();
break;
}
}
return retval;
}
// Rfu equivalent of LinkMain2
bool32 RfuMain2(void)
{
bool32 retval = FALSE;
if (!gRfu.isShuttingDown)
{
if (gRfu.parentChild == MODE_PARENT)
retval = RfuMain2_Parent();
RfuCheckErrorStatus();
}
return retval;
}
static void SetHostRfuUsername(void)
{
StringCopy(gHostRfuUsername, gSaveBlock2Ptr->playerName);
}
void ResetHostRfuGameData(void)
{
memset(&gHostRfuGameData, 0, RFU_GAME_NAME_LENGTH);
InitHostRfuGameData(&gHostRfuGameData, ACTIVITY_NONE, FALSE, 0);
}
void SetHostRfuGameData(u8 activity, u32 partnerInfo, bool32 startedActivity)
{
InitHostRfuGameData(&gHostRfuGameData, activity, startedActivity, partnerInfo);
}
void SetHostRfuWonderFlags(bool32 hasNews, bool32 hasCard)
{
gHostRfuGameData.compatibility.hasNews = hasNews;
gHostRfuGameData.compatibility.hasCard = hasCard;
}
void SetTradeBoardRegisteredMonInfo(u32 type, u32 species, u32 level)
{
gHostRfuGameData.tradeType = type;
gHostRfuGameData.tradeSpecies = species;
gHostRfuGameData.tradeLevel = level;
}
u8 GetLinkPlayerInfoFlags(s32 playerId)
{
u8 retval = PINFO_ACTIVE_FLAG;
retval |= (gLinkPlayers[playerId].gender << PINFO_GENDER_SHIFT);
retval |= (gLinkPlayers[playerId].trainerId & PINFO_TID_MASK);
return retval;
}
void GetOtherPlayersInfoFlags(void)
{
struct RfuGameData *data = &gHostRfuGameData;
s32 i;
for (i = 1; i < GetLinkPlayerCount(); i++)
data->partnerInfo[i - 1] = GetLinkPlayerInfoFlags(i);
}
void UpdateGameData_GroupLockedIn(bool8 startedActivity)
{
gHostRfuGameData.startedActivity = startedActivity;
rfu_REQ_configGameData(0, RFU_SERIAL_GAME, (void *)&gHostRfuGameData, gHostRfuUsername);
}
void UpdateGameData_SetActivity(u8 activity, u32 partnerInfo, bool32 startedActivity)
{
if (activity != ACTIVITY_NONE)
SetHostRfuGameData(activity, partnerInfo, startedActivity);
rfu_REQ_configGameData(0, RFU_SERIAL_GAME, (void *)&gHostRfuGameData, gHostRfuUsername);
}
void SetUnionRoomChatPlayerData(u32 numPlayers)
{
s32 i;
u32 numConnectedChildren;
u32 partnerInfo;
s32 slots;
if (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
{
numConnectedChildren = 0;
partnerInfo = 0;
slots = gRfu.parentSlots ^ gRfu.disconnectSlots;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((slots >> i) & 1)
{
// 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 == numPlayers - 1)
break;
}
}
UpdateGameData_SetActivity(ACTIVITY_CHAT | IN_UNION_ROOM, partnerInfo, FALSE);
}
}
void RfuSetErrorParams(u32 errorInfo)
{
if (gRfu.errorState == RFU_ERROR_STATE_NONE)
{
gRfu.errorParam0 = lman.param[0];
gRfu.errorParam1 = lman.param[1];
gRfu.errorInfo = errorInfo;
gRfu.errorState = RFU_ERROR_STATE_OCCURRED;
}
}
static void ResetErrorState(void)
{
gRfu.errorState = RFU_ERROR_STATE_NONE;
}
void RfuSetIgnoreError(bool32 enable)
{
if (!enable)
gRfu.errorState = RFU_ERROR_STATE_NONE;
else
gRfu.errorState = RFU_ERROR_STATE_IGNORE;
}
static void DisconnectNewChild(void)
{
SendDisconnectCommand(lman.acceptSlot_flag, RFU_DISCONNECT_ERROR);
gRfu.callback = NULL;
}
static void StartDisconnectNewChild(void)
{
gRfu.callback = DisconnectNewChild;
}
static void LinkManagerCB_Parent(u8 msg, u8 paramCount)
{
u8 i;
u8 disconnectFlag = 0;
switch (msg)
{
case LMAN_MSG_INITIALIZE_COMPLETED:
gRfu.state = RFUSTATE_PARENT_CONNECT;
break;
case LMAN_MSG_NEW_CHILD_CONNECT_DETECTED:
break;
case LMAN_MSG_NEW_CHILD_CONNECT_ACCEPTED:
ParentResetChildRecvMetadata(lman.param[0]);
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((lman.param[0] >> i) & 1)
{
struct RfuGameData *data = (void *)gRfuLinkStatus->partner[i].gname;
if (data->activity == GetHostRfuGameData()->activity)
{
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
{
disconnectFlag |= (1 << i);
}
}
}
if (disconnectFlag)
{
rfu_REQ_disconnect(disconnectFlag);
rfu_waitREQComplete();
}
break;
case LMAN_MSG_NEW_CHILD_CONNECT_REJECTED:
break;
case LMAN_MSG_SEARCH_CHILD_PERIOD_EXPIRED:
break;
case LMAN_MSG_END_WAIT_CHILD_NAME:
if (gRfu.acceptSlot_flag != lman.acceptSlot_flag)
{
rfu_REQ_disconnect(gRfu.acceptSlot_flag ^ lman.acceptSlot_flag);
rfu_waitREQComplete();
}
gRfu.state = RFUSTATE_PARENT_FINALIZE_START;
break;
case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY:
gRfu.linkLossRecoveryState = 1;
break;
case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
gRfu.linkLossRecoveryState = 3;
break;
case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED:
case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
gRfu.linkLossRecoveryState = 4;
gRfu.parentSlots &= ~lman.param[0];
if (gReceivedRemoteLinkPlayers == 1)
{
if (gRfu.parentSlots == 0)
RfuSetErrorParams(msg);
else
StartDisconnectNewChild();
}
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg);
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);
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:
RfuSetErrorParams(msg);
RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg);
gRfu.parentFinished = TRUE;
break;
}
}
static void LinkManagerCB_Child(u8 msg, u8 unused1)
{
switch (msg)
{
case LMAN_MSG_INITIALIZE_COMPLETED:
gRfu.state = RFUSTATE_CHILD_CONNECT;
break;
case LMAN_MSG_PARENT_FOUND:
gRfu.parentId = lman.param[0];
break;
case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED:
break;
case LMAN_MSG_CONNECT_PARENT_SUCCESSED:
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:
gRfu.state = RFUSTATE_CHILD_TRY_JOIN;
gRfu.leaveGroupStatus = RFU_STATUS_OK;
gRfu.childRecvStatus = RFU_STATUS_OK;
rfu_setRecvBuffer(TYPE_NI, gRfu.childSlot, &gRfu.childRecvStatus, sizeof(gRfu.childRecvStatus));
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:
gRfu.linkLossRecoveryState = 2;
if (gRfu.childRecvStatus == RFU_STATUS_JOIN_GROUP_NO)
break;
case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
if (gRfu.linkLossRecoveryState != 2)
gRfu.linkLossRecoveryState = 4;
if (gRfu.childRecvStatus != RFU_STATUS_LEAVE_GROUP)
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg);
Debug_PrintString(sASCII_LinkLossDisconnect, 5, 5);
if (gReceivedRemoteLinkPlayers == 1)
RfuSetErrorParams(msg);
break;
case LMAN_MSG_LINK_LOSS_DETECTED_AND_START_RECOVERY:
gRfu.linkLossRecoveryState = 1;
Debug_PrintString(sASCII_LinkLossRecoveryNow, 5, 5);
break;
case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
gRfu.linkLossRecoveryState = 3;
gRfu.linkRecovered = TRUE;
break;
case 0x34: // ? Not a valid LMAN_MSG value
break;
case LMAN_MSG_RFU_POWER_DOWN:
case LMAN_MSG_MANAGER_STOPPED:
case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET:
break;
case LMAN_MSG_LMAN_API_ERROR_RETURN:
RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg);
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);
RfuSetErrorParams(msg);
gRfu.parentFinished = TRUE;
break;
}
}
static void ParentResetChildRecvMetadata(s32 slot)
{
s32 i;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((slot >> i) & 1)
{
gRfu.numChildRecvErrors[i] = 0;
gRfu.childRecvIds[i] = 0xFF;
}
}
}
static u8 GetNewChildrenInUnionRoomChat(s32 emptySlotMask)
{
u8 ret = 0;
u8 i;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if ((emptySlotMask >> i) & 1)
{
struct RfuGameData *data = (void *)gRfuLinkStatus->partner[i].gname;
if (data->activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
ret |= (1 << i);
}
}
return ret;
}
static void LinkManagerCB_UnionRoom(u8 msg, u8 paramCount)
{
u8 acceptSlot;
switch (msg)
{
case LMAN_MSG_INITIALIZE_COMPLETED:
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 (GetHostRfuGameData()->activity == (ACTIVITY_CHAT | IN_UNION_ROOM) && !gRfu.stopNewConnections)
{
u8 newChildren = GetNewChildrenInUnionRoomChat(lman.param[0]);
if (newChildren != 0)
{
acceptSlot = 1 << Rfu_GetIndexOfNewestChild(newChildren);
if (gRfu.newChildQueue == 0 && !gRfu.playerExchangeActive)
{
gRfu.nextChildBits = acceptSlot;
gRfu.newChildQueue |= (acceptSlot ^ newChildren);
gRfu.playerExchangeActive = TRUE;
}
else
{
gRfu.newChildQueue |= newChildren;
}
}
if (newChildren != lman.param[0])
{
gRfu.disconnectSlots |= (newChildren ^ lman.param[0]);
gRfu.disconnectMode = RFU_DISCONNECT_NORMAL;
}
}
else if (GetHostRfuGameData()->activity == (ACTIVITY_PLYRTALK | IN_UNION_ROOM))
{
rfu_REQ_disconnect(lman.acceptSlot_flag);
rfu_waitREQComplete();
}
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 (GetHostRfuGameData()->activity != (ACTIVITY_CHAT | IN_UNION_ROOM) && lman.acceptCount > 1)
{
acceptSlot = 1 << Rfu_GetIndexOfNewestChild(lman.param[0]);
rfu_REQ_disconnect(lman.acceptSlot_flag ^ acceptSlot);
rfu_waitREQComplete();
}
if (gRfu.state == RFUSTATE_UR_STOP_MANAGER_END)
gRfu.state = RFUSTATE_UR_FINALIZE;
break;
break;
case LMAN_MSG_PARENT_FOUND:
gRfu.parentId = lman.param[0];
break;
case LMAN_MSG_SEARCH_PARENT_PERIOD_EXPIRED:
break;
case LMAN_MSG_CONNECT_PARENT_SUCCESSED:
gRfu.childSlot = lman.param[0];
break;
case LMAN_MSG_CONNECT_PARENT_FAILED:
gRfu.state = RFUSTATE_UR_CONNECT_END;
if (gRfu.connectParentFailures < 2)
{
gRfu.connectParentFailures++;
CreateTask(Task_TryConnectToUnionRoomParent, 2);
}
else
{
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg);
}
break;
case LMAN_MSG_CHILD_NAME_SEND_COMPLETED:
gRfu.state = RFUSTATE_UR_PLAYER_EXCHANGE;
RfuSetStatus(RFU_STATUS_CHILD_SEND_COMPLETE, 0);
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])
gRfu.linkLossRecoveryState = 1;
break;
case LMAN_MSG_LINK_RECOVERY_SUCCESSED:
gRfu.linkLossRecoveryState = 3;
if (gRfuLinkStatus->parentChild == MODE_CHILD)
gRfu.linkRecovered = TRUE;
break;
case LMAN_MSG_LINK_LOSS_DETECTED_AND_DISCONNECTED:
gRfu.linkLossRecoveryState = 2;
case LMAN_MSG_LINK_RECOVERY_FAILED_AND_DISCONNECTED:
if (gRfu.linkLossRecoveryState != 2)
gRfu.linkLossRecoveryState = 4;
if (gRfu.parentChild == MODE_PARENT)
{
if (gReceivedRemoteLinkPlayers == 1)
{
gRfu.parentSlots &= ~(lman.param[0]);
if (gRfu.parentSlots == 0)
RfuSetErrorParams(msg);
else
StartDisconnectNewChild();
}
}
else if (gRfu.disconnectMode != RFU_DISCONNECT_NORMAL && gReceivedRemoteLinkPlayers == 1)
{
RfuSetErrorParams(msg);
rfu_LMAN_stopManager(FALSE);
}
if (gRfuLinkStatus->parentChild == MODE_NEUTRAL
&& !lman.pcswitch_flag
&& FuncIsActiveTask(Task_UnionRoomListen) == TRUE)
gRfu.state = RFUSTATE_UR_CONNECT;
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, msg);
break;
case LMAN_MSG_LINK_DISCONNECTED_BY_USER:
gRfu.disconnectSlots = 0;
break;
case LMAN_MSG_RFU_POWER_DOWN:
case LMAN_MSG_MANAGER_STOPPED:
case LMAN_MSG_MANAGER_FORCED_STOPPED_AND_RFU_RESET:
break;
case LMAN_MSG_LMAN_API_ERROR_RETURN:
RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg);
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:
RfuSetErrorParams(msg);
RfuSetStatus(RFU_STATUS_FATAL_ERROR, msg);
gRfu.parentFinished = FALSE;
break;
}
}
void RfuSetNormalDisconnectMode(void)
{
gRfu.disconnectMode = RFU_DISCONNECT_NORMAL;
}
void RfuSetStatus(u8 status, u16 errorInfo)
{
gRfu.status = status;
gRfu.errorInfo = errorInfo;
}
u8 RfuGetStatus(void)
{
return gRfu.status;
}
bool32 RfuHasErrored(void)
{
u32 status = RfuGetStatus();
if (status == RFU_STATUS_FATAL_ERROR || status == RFU_STATUS_CONNECTION_ERROR)
return TRUE;
else
return FALSE;
}
bool32 Rfu_IsPlayerExchangeActive(void)
{
return gRfu.playerExchangeActive;
}
bool8 Rfu_IsMaster(void)
{
return gRfu.parentChild;
}
void RfuVSync(void)
{
rfu_LMAN_syncVBlank();
}
void ClearRecvCommands(void)
{
CpuFill32(0, gRecvCmds, sizeof(gRecvCmds));
}
static void VBlank_RfuIdle(void)
{
LoadOam();
ProcessSpriteCopyRequests();
TransferPlttBuffer();
}
// Unused
static void Debug_RfuIdle(void)
{
s32 i;
ResetSpriteData();
FreeAllSpritePalettes();
ResetTasks();
ResetPaletteFade();
SetVBlankCallback(VBlank_RfuIdle);
if (IsWirelessAdapterConnected())
{
gLinkType = LINKTYPE_TRADE;
SetWirelessCommType1();
OpenLink();
SeedRng(gMain.vblankCounter2);
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);
RunTasks();
AnimateSprites();
BuildOamBuffer();
UpdatePaletteFade();
CreateTask_RfuIdle();
SetMainCallback2(CB2_RfuIdle);
}
}
bool32 IsUnionRoomListenTaskActive(void)
{
return FuncIsActiveTask(Task_UnionRoomListen);
}
void CreateTask_RfuIdle(void)
{
if (!FuncIsActiveTask(Task_Idle))
gRfu.idleTaskId = CreateTask(Task_Idle, 0);
}
void DestroyTask_RfuIdle(void)
{
if (FuncIsActiveTask(Task_Idle) == TRUE)
DestroyTask(gRfu.idleTaskId);
}
static void CB2_RfuIdle(void)
{
RunTasks();
AnimateSprites();
BuildOamBuffer();
UpdatePaletteFade();
}
void InitializeRfuLinkManager_LinkLeader(u32 groupMax)
{
gRfu.parentChild = MODE_PARENT;
SetHostRfuUsername();
rfu_LMAN_initializeManager(LinkManagerCB_Parent, NULL);
sRfuReqConfig = sRfuReqConfigTemplate;
sRfuReqConfig.availSlot_flag = sAvailSlots[groupMax - 1];
CreateTask_ParentSearchForChildren();
}
void InitializeRfuLinkManager_JoinGroup(void)
{
gRfu.parentChild = MODE_CHILD;
SetHostRfuUsername();
rfu_LMAN_initializeManager(LinkManagerCB_Child, MSCCallback_Child);
CreateTask_ChildSearchForParent();
}
void InitializeRfuLinkManager_EnterUnionRoom(void)
{
gRfu.parentChild = MODE_P_C_SWITCH;
SetHostRfuUsername();
rfu_LMAN_initializeManager(LinkManagerCB_UnionRoom, NULL);
sRfuReqConfig = sRfuReqConfigTemplate;
sRfuReqConfig.linkRecovery_enable = 0;
sRfuReqConfig.linkRecovery_period = 600;
gRfu.searchTaskId = CreateTask(Task_UnionRoomListen, 1);
}
static u16 ReadU16(const void *ptr)
{
const u8 *ptr_ = ptr;
return (ptr_[1] << 8) | (ptr_[0]);
}
static u8 GetPartnerIndexByNameAndTrainerID(const u8 *name, u16 id)
{
u8 i;
u8 idx = 0xFF;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
u16 trainerId = ReadU16(((struct RfuGameData *)gRfuLinkStatus->partner[i].gname)->compatibility.playerTrainerId);
if (IsRfuSerialNumberValid(gRfuLinkStatus->partner[i].serialNo)
&& !StringCompare(name, gRfuLinkStatus->partner[i].uname)
&& id == trainerId)
{
idx = i;
if (gRfuLinkStatus->partner[i].slot != 0xFF)
break;
}
}
return idx;
}
static void RfuReqDisconnectSlot(u32 slot)
{
rfu_REQ_disconnect(slot);
rfu_waitREQComplete();
gRfu.parentSlots &= ~slot;
rfu_clearSlot(1, gRfu.parentSendSlot);
rfu_UNI_setSendData(gRfu.parentSlots, gRfu.recvCmds, sizeof(gRfu.recvCmds));
gRfu.parentSendSlot = Rfu_GetIndexOfNewestChild(gRfu.parentSlots);
}
void RequestDisconnectSlotByTrainerNameAndId(const u8 *name, u16 id)
{
u8 index = GetPartnerIndexByNameAndTrainerID(name, id);
if (index != 0xFF)
RfuReqDisconnectSlot(1 << index);
}
void Rfu_DisconnectPlayerById(u32 playerIdx)
{
if (playerIdx != 0)
{
s32 i;
u8 toDisconnect = 0;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
if (gRfu.linkPlayerIdx[i] == playerIdx && (gRfu.parentSlots >> i) & 1)
toDisconnect |= 1 << i;
}
if (toDisconnect)
SendDisconnectCommand(toDisconnect, RFU_DISCONNECT_NORMAL);
}
}
#define tDisconnectPlayers data[0]
#define tDisconnectMode data[1]
static void Task_SendDisconnectCommand(u8 taskId)
{
if (gSendCmd[0] == 0 && !gRfu.playerExchangeActive)
{
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 SendDisconnectCommand(u32 playersToDisconnect, u32 disconnectMode)
{
u8 taskId = FindTaskIdByFunc(Task_SendDisconnectCommand);
if (taskId == TASK_NONE)
{
taskId = CreateTask(Task_SendDisconnectCommand, 5);
gTasks[taskId].tDisconnectPlayers = playersToDisconnect;
}
else
{
// Task is already active, just add the new players to disconnect
gTasks[taskId].tDisconnectPlayers |= playersToDisconnect;
}
gTasks[taskId].tDisconnectMode = disconnectMode;
}
#undef tDisconnectMode
#define tTime data[15]
static void Task_RfuReconnectWithParent(u8 taskId)
{
s16 *data = gTasks[taskId].data;
if (CanTryReconnectParent())
{
u8 id = GetPartnerIndexByNameAndTrainerID((u8 *)data, ReadU16(&data[8]));
if (id != 0xFF)
{
if (gRfuLinkStatus->partner[id].slot != 0xFF)
{
gRfu.reconnectParentId = id;
if (TryReconnectParent())
DestroyTask(taskId);
}
else if (GetHostRfuGameData()->activity == ACTIVITY_WONDER_CARD
|| GetHostRfuGameData()->activity == ACTIVITY_WONDER_NEWS)
{
tTime++;
}
else
{
// 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
{
tTime++;
gRfu.reconnectParentId = id;
}
}
else
{
tTime++;
}
if (tTime > 240)
{
// Timeout error
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7);
DestroyTask(taskId);
}
}
#undef tTime
void CreateTask_RfuReconnectWithParent(const u8 *name, u16 trainerId)
{
u8 taskId;
s16 *data;
gRfu.status = RFU_STATUS_OK;
taskId = CreateTask(Task_RfuReconnectWithParent, 3);
data = gTasks[taskId].data;
StringCopy((u8 *)(data), name);
data[8] = trainerId;
}
static bool32 IsPartnerActivityIncompatible(s16 activity, struct RfuGameData *partner)
{
if (GetHostRfuGameData()->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 (partner->activity != IN_UNION_ROOM)
{
// Partner not in union room
return TRUE;
}
else if (activity == (ACTIVITY_TRADE | IN_UNION_ROOM))
{
// Verify that the trade offered hasn't changed
struct RfuGameData *original = &gRfu.parent;
if (original->tradeSpecies == SPECIES_EGG)
{
if (partner->tradeSpecies == original->tradeSpecies)
return FALSE;
else
return TRUE;
}
else if (partner->tradeSpecies != original->tradeSpecies
|| partner->tradeLevel != original->tradeLevel
|| partner->tradeType != original->tradeType)
{
return TRUE;
}
}
return FALSE;
}
#define tTime data[0]
#define tActivity data[1]
static void Task_TryConnectToUnionRoomParent(u8 taskId)
{
// Stop task if player is the new parent
if (gRfu.status == RFU_STATUS_NEW_CHILD_DETECTED)
DestroyTask(taskId);
if (++gTasks[taskId].tTime > 300)
{
// Timeout error
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7);
DestroyTask(taskId);
}
// Check if parent should be searched for
if (gRfu.parentId != 0 && lman.parent_child == MODE_CHILD)
{
// Search for parent
u16 trainerId = ReadU16(gRfu.parent.compatibility.playerTrainerId);
u8 id = GetPartnerIndexByNameAndTrainerID(gRfu.parentName, trainerId);
if (id != 0xFF)
{
// Parent found, try to connect
if (!IsPartnerActivityIncompatible(gTasks[taskId].tActivity, (void *)gRfuLinkStatus->partner[id].gname))
{
if (gRfuLinkStatus->partner[id].slot != 0xFF && !rfu_LMAN_CHILD_connectParent(gRfuLinkStatus->partner[id].id, 90))
{
// Succesfully connected to parent
gRfu.state = RFUSTATE_CONNECTED;
DestroyTask(taskId);
}
}
else
{
// Incompatible partner activity
RfuSetStatus(RFU_STATUS_CONNECTION_ERROR, F_RFU_ERROR_5 | F_RFU_ERROR_6 | F_RFU_ERROR_7);
DestroyTask(taskId);
}
}
}
}
void TryConnectToUnionRoomParent(const u8 *name, struct RfuGameData *parent, u8 activity)
{
u8 taskId, listenTaskId;
gRfu.connectParentFailures = 0;
gRfu.status = RFU_STATUS_OK;
StringCopy(gRfu.parentName, name);
memcpy(&gRfu.parent, parent, RFU_GAME_NAME_LENGTH);
rfu_LMAN_forceChangeSP();
taskId = CreateTask(Task_TryConnectToUnionRoomParent, 2);
gTasks[taskId].tActivity = activity;
listenTaskId = FindTaskIdByFunc(Task_UnionRoomListen);
if (activity == (ACTIVITY_CHAT | IN_UNION_ROOM))
{
if (listenTaskId != TASK_NONE)
gTasks[listenTaskId].tConnectingForChat = TRUE;
}
else
{
if (listenTaskId != TASK_NONE)
gTasks[listenTaskId].tConnectingForChat = FALSE;
}
}
bool8 IsRfuRecoveringFromLinkLoss(void)
{
if (gRfu.linkLossRecoveryState == 1)
return TRUE;
else
return FALSE;
}
bool32 IsRfuCommunicatingWithAllChildren(void)
{
s32 i;
for (i = 0; i < RFU_CHILD_MAX; i++)
{
// 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;
}
return TRUE;
}
static void Debug_PrintEmpty(void)
{
s32 i;
for (i = 0; i < 20; i++)
Debug_PrintString(sASCII_30Spaces, 0, i);
}
static void Debug_PrintStatus(void)
{
s32 i, j;
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++)
{
if ((gRfuLinkStatus->getNameFlag >> i) & 1)
{
Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
Debug_PrintString((void *)gRfuLinkStatus->partner[i].gname, 6, i + 3);
Debug_PrintString(gRfuLinkStatus->partner[i].uname, 22, i + 3);
}
}
for (i = 0; i < RFU_CHILD_MAX; i++)
{
for (j = 0; j < COMM_SLOT_LENGTH; j++)
Debug_PrintNum(gRfu.childRecvBuffer[i][j], j * 2, i + 11, 2);
}
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(sASCII_15Spaces, 6, i + 3);
Debug_PrintString(sASCII_8Spaces, 22, i + 3);
}
Debug_PrintNum(gRfuLinkStatus->partner[gRfu.childSlot].serialNo, 1, 3, 4);
Debug_PrintString((void *)gRfuLinkStatus->partner[gRfu.childSlot].gname, 6, 3);
Debug_PrintString(gRfuLinkStatus->partner[gRfu.childSlot].uname, 22, 3);
}
else
{
for (i = 0; i < gRfuLinkStatus->findParentCount; i++)
{
if (gRfuLinkStatus->partner[i].slot != 0xFF)
{
Debug_PrintNum(gRfuLinkStatus->partner[i].serialNo, 1, i + 3, 4);
Debug_PrintNum(gRfuLinkStatus->partner[i].id, 6, i + 3, 4);
Debug_PrintString(gRfuLinkStatus->partner[i].uname, 22, i + 3);
}
}
for (; i < RFU_CHILD_MAX; i++)
{
Debug_PrintNum(0, 1, i + 3, 4);
Debug_PrintString(sASCII_15Spaces, 6, i + 3);
Debug_PrintString(sASCII_8Spaces, 22, i + 3);
}
}
}
static u32 GetRfuSendQueueLength(void)
{
return gRfu.sendQueue.count;
}
u32 GetRfuRecvQueueLength(void)
{
return gRfu.recvQueue.count;
}
static void Task_Idle(u8 taskId)
{
}
View Git Blame Copy Permalink