From 9b9ae3d3374dd61870d47f025ffc0346a0b6839c Mon Sep 17 00:00:00 2001
From: PikalaxALT <PikalaxALT@gmail.com>
Date: Sat, 29 Feb 2020 14:30:01 -0500
Subject: through sub_8080E6C

---
 src/battle_records.c |   6 +-
 src/cable_club.c     | 397 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/link.c           |   8 +-
 src/trainer_card.c   | 248 ++++++++++++++++----------------
 src/union_room.c     |  20 +--
 5 files changed, 540 insertions(+), 139 deletions(-)
 create mode 100644 src/cable_club.c

(limited to 'src')

diff --git a/src/battle_records.c b/src/battle_records.c
index 07ff665d9..e2ae94f65 100644
--- a/src/battle_records.c
+++ b/src/battle_records.c
@@ -419,7 +419,7 @@ void ClearPlayerLinkBattleRecords(void)
 
 static void IncTrainerCardWinCount(s32 battlerId)
 {
-    u16 *wins = &gTrainerCards[battlerId].linkBattleWins;
+    u16 *wins = &gTrainerCards[battlerId].rse.linkBattleWins;
     (*wins)++;
     if (*wins > 9999)
         *wins = 9999;
@@ -427,7 +427,7 @@ static void IncTrainerCardWinCount(s32 battlerId)
 
 static void IncTrainerCardLossCount(s32 battlerId)
 {
-    u16 *losses = &gTrainerCards[battlerId].linkBattleLosses;
+    u16 *losses = &gTrainerCards[battlerId].rse.linkBattleLosses;
     (*losses)++;
     if (*losses > 9999)
         *losses = 9999;
@@ -453,7 +453,7 @@ void TryRecordLinkBattleOutcome(s32 battlerId)
     if (gSaveBlock1Ptr->location.mapGroup != MAP_GROUP(UNION_ROOM) || gSaveBlock1Ptr->location.mapNum != MAP_NUM(UNION_ROOM))
     {
         UpdateBattleOutcomeOnTrainerCards(battlerId);
-        AddOpponentLinkBattleRecord(&gSaveBlock2Ptr->linkBattleRecords, gTrainerCards[battlerId].playerName, gTrainerCards[battlerId].trainerId, gBattleOutcome, gLinkPlayers[battlerId].language);
+        AddOpponentLinkBattleRecord(&gSaveBlock2Ptr->linkBattleRecords, gTrainerCards[battlerId].rse.playerName, gTrainerCards[battlerId].rse.trainerId, gBattleOutcome, gLinkPlayers[battlerId].language);
     }
 }
 
diff --git a/src/cable_club.c b/src/cable_club.c
new file mode 100644
index 000000000..348a2a83d
--- /dev/null
+++ b/src/cable_club.c
@@ -0,0 +1,397 @@
+#include "global.h"
+#include "gflib.h"
+#include "event_data.h"
+#include "event_scripts.h"
+#include "field_message_box.h"
+#include "link.h"
+#include "overworld.h"
+#include "new_menu_helpers.h"
+#include "script.h"
+#include "strings.h"
+#include "task.h"
+#include "trainer_card.h"
+#include "constants/songs.h"
+
+void sub_80809F8(u8 taskId);
+void sub_8080A4C(u8 taskId);
+void sub_8080AD0(u8 taskId);
+void sub_8080B20(u8 taskId);
+void sub_8080BC8(u8 taskId);
+void sub_8080C6C(u8 taskId);
+void sub_8080CDC(u8 taskId);
+void sub_8080DC0(u8 taskId);
+void sub_8080E6C(u8 taskId);
+void sub_8080F78(u8 taskId);
+void sub_8080FB4(u8 taskId);
+void sub_8080FF0(u8 taskId);
+bool8 sub_808102C(u8 taskId);
+
+static const struct WindowTemplate gUnknown_83C6AB0 = {
+    .bg = 0,
+    .tilemapLeft = 16,
+    .tilemapTop = 11,
+    .width = 11,
+    .height = 2,
+    .paletteNum = 15,
+    .baseBlock = 0x125
+};
+
+const u8 *const gUnknown_83C6AB8[] = {
+    gUnknown_841DF8B,
+    gUnknown_841DF92,
+    gUnknown_841DF99,
+    gUnknown_841DFA0
+};
+
+void sub_8080748(u8 a0, u8 a1)
+{
+    u8 taskId;
+    if (FindTaskIdByFunc(sub_80809F8) == 0xFF)
+    {
+        taskId = CreateTask(sub_80809F8, 80);
+        gTasks[taskId].data[1] = a0;
+        gTasks[taskId].data[2] = a1;
+    }
+}
+
+void sub_808078C(u16 windowId, s32 num)
+{
+    ConvertIntToDecimalStringN(gStringVar1, num, STR_CONV_MODE_LEFT_ALIGN, 1);
+    SetStdWindowBorderStyle(windowId, FALSE);
+    StringExpandPlaceholders(gStringVar4, gUnknown_841DF82);
+    AddTextPrinterParameterized(windowId, 2, gStringVar4, 0, 0, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(windowId, 3);
+}
+
+void sub_80807E8(u16 windowId)
+{
+    ClearStdWindowAndFrame(windowId, FALSE);
+    CopyWindowToVram(windowId, 3);
+}
+
+void sub_8080808(u8 taskId, u8 num)
+{
+    s16 *data = gTasks[taskId].data;
+    if (num != data[3])
+    {
+        if (num < 2)
+            sub_80807E8(data[5]);
+        else
+            sub_808078C(data[5], num);
+        data[3] = num;
+    }
+}
+
+u16 sub_8080844(u8 lower, u8 higher)
+{
+    switch (GetLinkPlayerDataExchangeStatusTimed(lower, higher))
+    {
+    case EXCHANGE_COMPLETE:
+        return 1;
+    case EXCHANGE_IN_PROGRESS:
+        return 3;
+    case EXCHANGE_STAT_4:
+        return 7;
+    case EXCHANGE_STAT_5:
+        return 9;
+    case EXCHANGE_STAT_6:
+        ConvertIntToDecimalStringN(gStringVar1, GetLinkPlayerCount_2(), STR_CONV_MODE_LEFT_ALIGN, 1);
+        return 4;
+    default:
+        return 0;
+    }
+}
+
+bool32 sub_80808BC(u8 taskId)
+{
+    if (HasLinkErrorOccurred() == TRUE)
+    {
+        gTasks[taskId].func = sub_8080FF0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+bool32 sub_80808F0(u8 taskId)
+{
+    if (JOY_NEW(B_BUTTON) && !IsLinkConnectionEstablished())
+    {
+        gLinkType = 0;
+        gTasks[taskId].func = sub_8080FB4;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+bool32 sub_808093C(u8 taskId)
+{
+    if (IsLinkConnectionEstablished())
+    {
+        SetSuppressLinkErrorMessage(TRUE);
+    }
+    if (JOY_NEW(B_BUTTON))
+    {
+        gLinkType = 0;
+        gTasks[taskId].func = sub_8080FB4;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+bool32 sub_8080990(u8 taskId)
+{
+    if (GetSioMultiSI() == TRUE)
+    {
+        gTasks[taskId].func = sub_8080FF0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_80809C4(u8 taskId)
+{
+    gTasks[taskId].data[0]++;
+    if (gTasks[taskId].data[0] == 10)
+    {
+        sub_800A474(2);
+        DestroyTask(taskId);
+    }
+}
+
+void sub_80809F8(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        OpenLinkTimed();
+        sub_800AA24();
+        ResetLinkPlayers();
+        data[5] = AddWindow(&gUnknown_83C6AB0);
+    }
+    else if (data[0] > 9)
+    {
+        gTasks[taskId].func = sub_8080A4C;
+    }
+    data[0]++;
+}
+
+void sub_8080A4C(u8 taskId)
+{
+    u8 linkPlayerCount = GetLinkPlayerCount_2();
+    if (sub_80808F0(taskId) != TRUE && sub_808093C(taskId) != TRUE && linkPlayerCount >= 2)
+    {
+        SetSuppressLinkErrorMessage(TRUE);
+        gTasks[taskId].data[3] = 0;
+        if (IsLinkMaster() == TRUE)
+        {
+            PlaySE(SE_PIN);
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = sub_8080AD0;
+        }
+        else
+        {
+            PlaySE(SE_BOO);
+            ShowFieldAutoScrollMessage(CableClub_Text_AwaitingLinkupBCancel);
+            gTasks[taskId].func = sub_8080CDC;
+        }
+    }
+}
+
+void sub_8080AD0(u8 taskId)
+{
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
+    {
+        gTasks[taskId].data[3] = 0;
+        gTasks[taskId].func = sub_8080B20;
+    }
+}
+
+void sub_8080B20(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s32 linkPlayerCount = GetLinkPlayerCount_2();
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE)
+    {
+        sub_8080808(taskId, linkPlayerCount);
+        if (JOY_NEW(A_BUTTON) && linkPlayerCount >= data[1])
+        {
+            sub_800A900(linkPlayerCount);
+            sub_80807E8(data[5]);
+            ConvertIntToDecimalStringN(gStringVar1, linkPlayerCount, STR_CONV_MODE_LEFT_ALIGN, 1);
+            ShowFieldAutoScrollMessage(CableClub_Text_StartLinkWithXPlayersAConfirmBCancel);
+            gTasks[taskId].func = sub_8080BC8;
+        }
+    }
+}
+
+void sub_8080BC8(u8 taskId)
+{
+    if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
+    {
+        if (GetSavedPlayerCount() != GetLinkPlayerCount_2())
+        {
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = sub_8080AD0;
+        }
+        else if (JOY_HELD(B_BUTTON))
+        {
+            ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
+            gTasks[taskId].func = sub_8080AD0;
+        }
+        else if (JOY_HELD(A_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+            CheckShouldAdvanceLinkState();
+            gTasks[taskId].func = sub_8080C6C;
+        }
+    }
+}
+
+void sub_8080C6C(u8 taskId)
+{
+    u8 lower = gTasks[taskId].data[1];
+    u8 higher = gTasks[taskId].data[2];
+    u16 *res;
+    if (sub_80808BC(taskId) != TRUE && sub_808102C(taskId) != TRUE)
+    {
+        if (GetLinkPlayerCount_2() != GetSavedPlayerCount())
+        {
+            gTasks[taskId].func = sub_8080FF0;
+        }
+        else
+        {
+            res = &gSpecialVar_Result;
+            *res = sub_8080844(lower, higher);
+            if (*res)
+                gTasks[taskId].func = sub_8080DC0;
+        }
+    }
+}
+
+void sub_8080CDC(u8 taskId)
+{
+    u8 lower = gTasks[taskId].data[1];
+    u8 higher = gTasks[taskId].data[2];
+    u16 *res;
+    if (sub_80808F0(taskId) != TRUE && sub_80808BC(taskId) != TRUE)
+    {
+        res = &gSpecialVar_Result;
+        *res = sub_8080844(lower, higher);
+        if (*res)
+        {
+            if (*res == 3 || *res == 4)
+            {
+                Link_TryStartSend5FFF();
+                HideFieldMessageBox();
+                gTasks[taskId].func = sub_8080F78;
+            }
+            else if (*res == 7 || *res == 9)
+            {
+                CloseLink();
+                HideFieldMessageBox();
+                gTasks[taskId].func = sub_8080F78;
+            }
+            else
+            {
+                gFieldLinkPlayerCount = GetLinkPlayerCount_2();
+                gLocalLinkPlayerId = GetMultiplayerId();
+                sub_800A900(gFieldLinkPlayerCount);
+                TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
+                gTasks[taskId].func = sub_8080E6C;
+            }
+        }
+    }
+}
+
+bool32 sub_8080D8C(void)
+{
+    int i;
+    u16 version;
+
+    for (i = 0; i < GetLinkPlayerCount(); i++)
+    {
+        version = gLinkPlayers[i].version & 0xFF;
+        if (version == VERSION_RUBY || version == VERSION_SAPPHIRE)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_8080DC0(u8 taskId)
+{
+    if (sub_80808BC(taskId) != TRUE)
+    {
+        if (gSpecialVar_Result == 4)
+        {
+            if (sub_8080D8C() == TRUE)
+                CloseLink();
+            else
+                Link_TryStartSend5FFF();
+            HideFieldMessageBox();
+            gTasks[taskId].func = sub_8080F78;
+        }
+        else if (gSpecialVar_Result == 3)
+        {
+            Link_TryStartSend5FFF();
+            HideFieldMessageBox();
+            gTasks[taskId].func = sub_8080F78;
+        }
+        else if (gSpecialVar_Result == 7 || gSpecialVar_Result == 9)
+        {
+            CloseLink();
+            HideFieldMessageBox();
+            gTasks[taskId].func = sub_8080F78;
+        }
+        else
+        {
+            gFieldLinkPlayerCount = GetLinkPlayerCount_2();
+            gLocalLinkPlayerId = GetMultiplayerId();
+            sub_800A900(gFieldLinkPlayerCount);
+            TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
+            gTasks[taskId].func = sub_8080E6C;
+            sub_800A474(2);
+        }
+    }
+}
+
+void sub_8080E6C(u8 taskId)
+{
+    u8 i;
+    u16 version;
+    u8 * dest;
+    if (sub_80808BC(taskId) != TRUE && GetBlockReceivedStatus() == sub_800A8A4())
+    {
+        for(i = 0; i < GetLinkPlayerCount(); i++)
+        {
+            version = gLinkPlayers[i].version & 0xFF;
+            if (version != VERSION_FIRE_RED && version != VERSION_LEAF_GREEN)
+            {
+                const struct TrainerCardRSE * src = (const struct TrainerCardRSE *)gBlockRecvBuffer[i];
+                gTrainerCards[i].rse = *src;
+                gTrainerCards[i].version = gLinkPlayers[i].version;
+            }
+            else
+            {
+                const struct TrainerCard * src = (const struct TrainerCard *)gBlockRecvBuffer[i];
+                gTrainerCards[i] = *src;
+            }
+        }
+        SetSuppressLinkErrorMessage(FALSE);
+        ResetBlockReceivedFlags();
+        HideFieldMessageBox();
+        if (gSpecialVar_Result == 1)
+        {
+            // Dumb trick required to match
+            if (gLinkType == 0x4411)
+                gFieldLinkPlayerCount += 0;
+            sub_80807E8(gTasks[taskId].data[5]);
+            EnableBothScriptContexts();
+            DestroyTask(taskId);
+        }
+        else
+        {
+            Link_TryStartSend5FFF();
+            gTasks[taskId].func = sub_8080F78;
+        }
+    }
+}
diff --git a/src/link.c b/src/link.c
index 26e223153..cb46a50ff 100644
--- a/src/link.c
+++ b/src/link.c
@@ -796,7 +796,7 @@ u8 GetLinkPlayerDataExchangeStatusTimed(int lower, int upper)
         if (lower > cmpVal || cmpVal > upper)
         {
             sPlayerDataExchangeStatus = EXCHANGE_STAT_6;
-            return 6;
+            return EXCHANGE_STAT_6;
         }
         else
         {
@@ -1006,15 +1006,15 @@ bool8 SendBlock(u8 unused, const void *src, u16 size)
     return InitBlockSend(src, size);
 }
 
-bool8 sub_800A474(u8 a0)
+bool8 sub_800A474(u8 blockRequestType)
 {
     if (gWirelessCommType == 1)
     {
-        return sub_80FA0F8(a0);
+        return sub_80FA0F8(blockRequestType);
     }
     if (gLinkCallback == NULL)
     {
-        gBlockRequestType = a0;
+        gBlockRequestType = blockRequestType;
         BuildSendCmd(LINKCMD_0xCCCC);
         return TRUE;
     }
diff --git a/src/trainer_card.c b/src/trainer_card.c
index d60738ee6..c35b09386 100644
--- a/src/trainer_card.c
+++ b/src/trainer_card.c
@@ -348,28 +348,30 @@ static const u8 sUnknown_83CD95C[] = {7, 6, 0, 0};
 
 static const struct TrainerCard sLinkPlayerTrainerCardTemplate1 = 
 {
-    .gender = MALE,
-    .stars = 4,
-    .hasPokedex = TRUE,
-    .caughtAllHoenn = TRUE,
-    .hasAllPaintings = TRUE,
-    .hofDebutHours = 999,
-    .hofDebutMinutes = 59,
-    .hofDebutSeconds = 59,
-    .caughtMonsCount = 200,
-    .trainerId = 0x6072,
-    .playTimeHours = 999,
-    .playTimeMinutes = 59,
-    .linkBattleWins = 5535,
-    .linkBattleLosses = 5535,
-    .battleTowerWins = 5535,
-    .battleTowerStraightWins = 5535,
-    .contestsWithFriends = 55555,
-    .pokeblocksWithFriends = 44444,
-    .pokemonTrades = 33333,
-    .money = 999999,
-    .var_28 = {0, 0, 0, 0},
-    .playerName = _("あかみ どりお"),
+    .rse = {
+        .gender = MALE,
+        .stars = 4,
+        .hasPokedex = TRUE,
+        .caughtAllHoenn = TRUE,
+        .hasAllPaintings = TRUE,
+        .hofDebutHours = 999,
+        .hofDebutMinutes = 59,
+        .hofDebutSeconds = 59,
+        .caughtMonsCount = 200,
+        .trainerId = 0x6072,
+        .playTimeHours = 999,
+        .playTimeMinutes = 59,
+        .linkBattleWins = 5535,
+        .linkBattleLosses = 5535,
+        .battleTowerWins = 5535,
+        .battleTowerStraightWins = 5535,
+        .contestsWithFriends = 55555,
+        .pokeblocksWithFriends = 44444,
+        .pokemonTrades = 33333,
+        .money = 999999,
+        .var_28 = {0, 0, 0, 0},
+        .playerName = _("あかみ どりお")
+    },
     .version = VERSION_FIRE_RED,
     .var_3A = 0,
     .berryCrushPoints = 5555,
@@ -386,28 +388,30 @@ static const struct TrainerCard sLinkPlayerTrainerCardTemplate1 =
 
 static const struct TrainerCard sLinkPlayerTrainerCardTemplate2 = 
 {
-    .gender = FEMALE,
-    .stars = 2,
-    .hasPokedex = TRUE,
-    .caughtAllHoenn = TRUE,
-    .hasAllPaintings = TRUE,
-    .hofDebutHours = 999,
-    .hofDebutMinutes = 59,
-    .hofDebutSeconds = 59,
-    .caughtMonsCount = 200,
-    .trainerId = 0x6072,
-    .playTimeHours = 999,
-    .playTimeMinutes = 59,
-    .linkBattleWins = 5535,
-    .linkBattleLosses = 5535,
-    .battleTowerWins = 65535,
-    .battleTowerStraightWins = 65535,
-    .contestsWithFriends = 55555,
-    .pokeblocksWithFriends = 44444,
-    .pokemonTrades = 33333,
-    .money = 999999,
-    .var_28 = {0, 0, 0, 0},
-    .playerName = _("るびさふぁこ！"),
+    .rse = {
+        .gender = FEMALE,
+        .stars = 2,
+        .hasPokedex = TRUE,
+        .caughtAllHoenn = TRUE,
+        .hasAllPaintings = TRUE,
+        .hofDebutHours = 999,
+        .hofDebutMinutes = 59,
+        .hofDebutSeconds = 59,
+        .caughtMonsCount = 200,
+        .trainerId = 0x6072,
+        .playTimeHours = 999,
+        .playTimeMinutes = 59,
+        .linkBattleWins = 5535,
+        .linkBattleLosses = 5535,
+        .battleTowerWins = 65535,
+        .battleTowerStraightWins = 65535,
+        .contestsWithFriends = 55555,
+        .pokeblocksWithFriends = 44444,
+        .pokemonTrades = 33333,
+        .money = 999999,
+        .var_28 = {0, 0, 0, 0},
+        .playerName = _("るびさふぁこ！")
+    },
     .version = 0,
     .var_3A = 0,
     .berryCrushPoints = 555,
@@ -744,16 +748,16 @@ static u8 GetTrainerStarCount(struct TrainerCard *trainerCard)
 {
     u8 stars = 0;
 
-    if (trainerCard->hofDebutHours != 0 || trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0)
+    if (trainerCard->rse.hofDebutHours != 0 || trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0)
         stars++;
 
-    if (trainerCard->caughtAllHoenn)
+    if (trainerCard->rse.caughtAllHoenn)
         stars++;
 
-    if (trainerCard->battleTowerStraightWins > 49)
+    if (trainerCard->rse.battleTowerStraightWins > 49)
         stars++;
 
-    if (trainerCard->hasAllPaintings)
+    if (trainerCard->rse.hasAllPaintings)
         stars++;
 
     return stars;
@@ -764,63 +768,63 @@ static void SetPlayerCardData(struct TrainerCard *trainerCard, u8 cardType)
     u32 playTime;
     u8 i;
 
-    trainerCard->gender = gSaveBlock2Ptr->playerGender;
-    trainerCard->playTimeHours = gSaveBlock2Ptr->playTimeHours;
-    trainerCard->playTimeMinutes = gSaveBlock2Ptr->playTimeMinutes;
+    trainerCard->rse.gender = gSaveBlock2Ptr->playerGender;
+    trainerCard->rse.playTimeHours = gSaveBlock2Ptr->playTimeHours;
+    trainerCard->rse.playTimeMinutes = gSaveBlock2Ptr->playTimeMinutes;
 
     playTime = GetGameStat(GAME_STAT_FIRST_HOF_PLAY_TIME);
     if (!GetGameStat(GAME_STAT_ENTERED_HOF))
         playTime = 0;
 
-    trainerCard->hofDebutHours = playTime >> 16;
-    trainerCard->hofDebutMinutes = (playTime >> 8) & 0xFF;
-    trainerCard->hofDebutSeconds = playTime & 0xFF;
+    trainerCard->rse.hofDebutHours = playTime >> 16;
+    trainerCard->rse.hofDebutMinutes = (playTime >> 8) & 0xFF;
+    trainerCard->rse.hofDebutSeconds = playTime & 0xFF;
     if ((playTime >> 16) > 999)
     {
-        trainerCard->hofDebutHours = 999;
-        trainerCard->hofDebutMinutes = 59;
-        trainerCard->hofDebutSeconds = 59;
+        trainerCard->rse.hofDebutHours = 999;
+        trainerCard->rse.hofDebutMinutes = 59;
+        trainerCard->rse.hofDebutSeconds = 59;
     }
 
-    trainerCard->hasPokedex = FlagGet(FLAG_SYS_POKEDEX_GET);
-    trainerCard->caughtAllHoenn = HasAllHoennMons();
-    trainerCard->caughtMonsCount = GetCaughtMonsCount();
+    trainerCard->rse.hasPokedex = FlagGet(FLAG_SYS_POKEDEX_GET);
+    trainerCard->rse.caughtAllHoenn = HasAllHoennMons();
+    trainerCard->rse.caughtMonsCount = GetCaughtMonsCount();
 
-    trainerCard->trainerId = (gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0];
+    trainerCard->rse.trainerId = (gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0];
 
-    trainerCard->linkBattleWins = GetCappedGameStat(GAME_STAT_LINK_BATTLE_WINS, 9999);
-    trainerCard->linkBattleLosses = GetCappedGameStat(GAME_STAT_LINK_BATTLE_LOSSES, 9999);
-    trainerCard->pokemonTrades = GetCappedGameStat(GAME_STAT_POKEMON_TRADES, 0xFFFF);
+    trainerCard->rse.linkBattleWins = GetCappedGameStat(GAME_STAT_LINK_BATTLE_WINS, 9999);
+    trainerCard->rse.linkBattleLosses = GetCappedGameStat(GAME_STAT_LINK_BATTLE_LOSSES, 9999);
+    trainerCard->rse.pokemonTrades = GetCappedGameStat(GAME_STAT_POKEMON_TRADES, 0xFFFF);
 
-    trainerCard->battleTowerWins = 0;
-    trainerCard->battleTowerStraightWins = 0;
-    trainerCard->contestsWithFriends = 0;
-    trainerCard->pokeblocksWithFriends = 0;
+    trainerCard->rse.battleTowerWins = 0;
+    trainerCard->rse.battleTowerStraightWins = 0;
+    trainerCard->rse.contestsWithFriends = 0;
+    trainerCard->rse.pokeblocksWithFriends = 0;
 
-    trainerCard->hasAllPaintings = FALSE;
+    trainerCard->rse.hasAllPaintings = FALSE;
 
-    trainerCard->money = GetMoney(&gSaveBlock1Ptr->money);
+    trainerCard->rse.money = GetMoney(&gSaveBlock1Ptr->money);
 
     for (i = 0; i < 4; i++)
-        trainerCard->var_28[i] = gSaveBlock1Ptr->easyChatProfile[i];
+        trainerCard->rse.var_28[i] = gSaveBlock1Ptr->easyChatProfile[i];
 
-    StringCopy(trainerCard->playerName, gSaveBlock2Ptr->playerName);
+    StringCopy(trainerCard->rse.playerName, gSaveBlock2Ptr->playerName);
 
     if (cardType == CARD_TYPE_FRLG)
     {
-        trainerCard->stars = GetTrainerStarCount(trainerCard);
+        trainerCard->rse.stars = GetTrainerStarCount(trainerCard);
     }
     else if (cardType == CARD_TYPE_EMERALD)
     {
-        trainerCard->stars = 0;
-        if (trainerCard->hofDebutHours != 0 || (trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0))
-            trainerCard->stars = cardType;
+        trainerCard->rse.stars = 0;
+        if (trainerCard->rse.hofDebutHours != 0 || (trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0))
+            trainerCard->rse.stars = cardType;
 
         if (HasAllKantoMons())
-            trainerCard->stars++;
+            trainerCard->rse.stars++;
 
         if (HasAllMons())
-            trainerCard->stars++;
+            trainerCard->rse.stars++;
     }
 }
 
@@ -833,11 +837,11 @@ void TrainerCard_GenerateCardForLinkPlayer(struct TrainerCard *trainerCard)
     if (GetCardType() != CARD_TYPE_FRLG)
         return;
 
-    trainerCard->stars = id;
-    if (trainerCard->hofDebutHours != 0 || trainerCard->hofDebutMinutes != 0 || trainerCard->hofDebutSeconds != 0)
-        trainerCard->stars = 1;
+    trainerCard->rse.stars = id;
+    if (trainerCard->rse.hofDebutHours != 0 || trainerCard->rse.hofDebutMinutes != 0 || trainerCard->rse.hofDebutSeconds != 0)
+        trainerCard->rse.stars = 1;
 
-    trainerCard->caughtAllHoenn = HasAllKantoMons();
+    trainerCard->rse.caughtAllHoenn = HasAllKantoMons();
     trainerCard->hasAllMons = HasAllMons();
     trainerCard->berriesPicked = gSaveBlock2Ptr->berryPick.berriesPicked;
     trainerCard->jumpsInRow = gSaveBlock2Ptr->pokeJump.jumpsInRow;
@@ -846,17 +850,17 @@ void TrainerCard_GenerateCardForLinkPlayer(struct TrainerCard *trainerCard)
     trainerCard->unionRoomNum = GetCappedGameStat(GAME_STAT_NUM_UNION_ROOM_BATTLES, 0xFFFF);
     trainerCard->var_4C = TRUE;
 
-    if (trainerCard->caughtAllHoenn)
-        trainerCard->stars++;
+    if (trainerCard->rse.caughtAllHoenn)
+        trainerCard->rse.stars++;
 
     if (trainerCard->hasAllMons)
-        trainerCard->stars++;
+        trainerCard->rse.stars++;
 
     if (trainerCard->berriesPicked >= 200 && trainerCard->jumpsInRow >= 200)
-        trainerCard->stars++;
+        trainerCard->rse.stars++;
 
-    id = ((u16)trainerCard->trainerId) % 8;
-    if (trainerCard->gender == FEMALE)
+    id = ((u16)trainerCard->rse.trainerId) % 8;
+    if (trainerCard->rse.gender == FEMALE)
         trainerCard->var_4F = sLinkTrainerCardFacilityClasses[1][id];
     else
         trainerCard->var_4F = sLinkTrainerCardFacilityClasses[0][id];
@@ -889,18 +893,18 @@ static void SetDataFromTrainerCard(void)
     sTrainerCardDataPtr->hasTrades = FALSE;
 
     memset(&sTrainerCardDataPtr->hasBadge, FALSE, BADGE_COUNT);
-    if (sTrainerCardDataPtr->trainerCard.hasPokedex)
+    if (sTrainerCardDataPtr->trainerCard.rse.hasPokedex)
         sTrainerCardDataPtr->hasPokedex++;
 
-    if (sTrainerCardDataPtr->trainerCard.hofDebutHours != 0
-     || sTrainerCardDataPtr->trainerCard.hofDebutMinutes != 0
-     || sTrainerCardDataPtr->trainerCard.hofDebutSeconds != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.hofDebutHours != 0
+     || sTrainerCardDataPtr->trainerCard.rse.hofDebutMinutes != 0
+     || sTrainerCardDataPtr->trainerCard.rse.hofDebutSeconds != 0)
         sTrainerCardDataPtr->hasHofResult++;
 
-    if (sTrainerCardDataPtr->trainerCard.linkBattleWins != 0 || sTrainerCardDataPtr->trainerCard.linkBattleLosses != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.linkBattleWins != 0 || sTrainerCardDataPtr->trainerCard.rse.linkBattleLosses != 0)
         sTrainerCardDataPtr->hasLinkResults++;
 
-    if (sTrainerCardDataPtr->trainerCard.pokemonTrades != 0)
+    if (sTrainerCardDataPtr->trainerCard.rse.pokemonTrades != 0)
         sTrainerCardDataPtr->hasTrades++;
 
     for (i = 0, badgeFlag = FLAG_BADGE01_GET; badgeFlag <= FLAG_BADGE08_GET; badgeFlag++, i++)
@@ -1094,7 +1098,7 @@ static void PrintNameOnCard(void)
 
     txtPtr = StringCopy(buffer[0], gText_TrainerCardName);
     txtPtr = buffer[1];
-    StringCopy(txtPtr, sTrainerCardDataPtr->trainerCard.playerName);
+    StringCopy(txtPtr, sTrainerCardDataPtr->trainerCard.rse.playerName);
     ConvertInternationalString(txtPtr, sTrainerCardDataPtr->language);
     StringAppend(buffer[0], txtPtr);
     AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardPlayerNameXPositions[sTrainerCardDataPtr->cardType], sTrainerCardPlayerNameYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer[0]);
@@ -1106,7 +1110,7 @@ static void PrintIdOnCard(void)
     u8* txtPtr;
 
     txtPtr = StringCopy(buffer, gText_TrainerCardIDNo);
-    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.trainerId, STR_CONV_MODE_LEADING_ZEROS, 5);
+    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.rse.trainerId, STR_CONV_MODE_LEADING_ZEROS, 5);
     AddTextPrinterParameterized3(1, sTrainerCardFontIds[1], sTrainerCardIdXPositions[sTrainerCardDataPtr->cardType], sTrainerCardIdYPositions[sTrainerCardDataPtr->cardType], sFireRedTrainerCardPage1TextColors, TEXT_SPEED_FF, buffer);
 }
 
@@ -1117,7 +1121,7 @@ static void PrintMoneyOnCard(void)
     u8 x;
 
     txtPtr = StringCopy(buffer, gText_TrainerCardYen);
-    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.money, STR_CONV_MODE_LEFT_ALIGN, 6);
+    ConvertIntToDecimalStringN(txtPtr, sTrainerCardDataPtr->trainerCard.rse.money, STR_CONV_MODE_LEFT_ALIGN, 6);
     if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
     {
         x = -122 - 6 * StringLength(buffer);
@@ -1147,7 +1151,7 @@ static void PrintPokedexOnCard(void)
 
     if (FlagGet(FLAG_SYS_POKEDEX_GET))
     {
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.caughtMonsCount, 0, 3);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.caughtMonsCount, 0, 3);
         if (sTrainerCardDataPtr->cardType != CARD_TYPE_EMERALD)
         {
             x = -120 - 6 * StringLength(buffer);
@@ -1175,8 +1179,8 @@ static void PrintTimeOnCard(void)
     minutes = gSaveBlock2Ptr->playTimeMinutes;
     if (sTrainerCardDataPtr->isLink)
     {
-        hours = sTrainerCardDataPtr->trainerCard.playTimeHours;
-        minutes = sTrainerCardDataPtr->trainerCard.playTimeMinutes;
+        hours = sTrainerCardDataPtr->trainerCard.rse.playTimeHours;
+        minutes = sTrainerCardDataPtr->trainerCard.rse.playTimeMinutes;
     }
 
     if (hours > 999)
@@ -1221,7 +1225,7 @@ static void PrintProfilePhraseOnCard(void)
 
 static void PrintNameOnCard2(void)
 {
-    StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->trainerCard.playerName);
+    StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->trainerCard.rse.playerName);
     ConvertInternationalString(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_NAME], sTrainerCardDataPtr->language);
     if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
     {
@@ -1254,13 +1258,13 @@ static void PrintHofTimeOnCard(void)
 
     if (sTrainerCardDataPtr->hasHofResult)
     {
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutHours, STR_CONV_MODE_RIGHT_ALIGN, 3);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutHours, STR_CONV_MODE_RIGHT_ALIGN, 3);
         txtPtr = StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], gText_Colon2, 2);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer, 3);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], gText_Colon2, 2);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.hofDebutSeconds, STR_CONV_MODE_LEADING_ZEROS, 2);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.hofDebutSeconds, STR_CONV_MODE_LEADING_ZEROS, 2);
         StringAppendN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_HOF_TIME], buffer, 3);
     }
 }
@@ -1282,9 +1286,9 @@ static void PrintLinkResultsNumsOnCard(void)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_RECORD], sLinkTrainerCardRecordStrings[sTrainerCardDataPtr->cardType]);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_WIN_LOSS], gText_WinLossRatio);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.linkBattleWins, STR_CONV_MODE_RIGHT_ALIGN, 4);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.linkBattleWins, STR_CONV_MODE_RIGHT_ALIGN, 4);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_WINS], buffer);
-        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.linkBattleLosses, STR_CONV_MODE_RIGHT_ALIGN, 4);
+        ConvertIntToDecimalStringN(buffer, sTrainerCardDataPtr->trainerCard.rse.linkBattleLosses, STR_CONV_MODE_RIGHT_ALIGN, 4);
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_LINK_LOSSES], buffer);
     }
 }
@@ -1306,7 +1310,7 @@ static void PrintTradesNumOnCard(void)
     if (sTrainerCardDataPtr->hasTrades)
     {
         StringCopy(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADES], gText_PokemonTrades);
-        ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT], sTrainerCardDataPtr->trainerCard.pokemonTrades, STR_CONV_MODE_RIGHT_ALIGN, 5);
+        ConvertIntToDecimalStringN(sTrainerCardDataPtr->strings[TRAINER_CARD_STRING_TRADE_COUNT], sTrainerCardDataPtr->trainerCard.rse.pokemonTrades, STR_CONV_MODE_RIGHT_ALIGN, 5);
     }
 }
 
@@ -1447,9 +1451,9 @@ static bool8 SetTrainerCardBgsAndPals(void)
         break;
     case 2:
         if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
-            LoadPalette(sEmeraldTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.stars], 0, 96);
+            LoadPalette(sEmeraldTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.rse.stars], 0, 96);
         else
-            LoadPalette(sFireRedTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.stars], 0, 96);
+            LoadPalette(sFireRedTrainerCardStarPals[sTrainerCardDataPtr->trainerCard.rse.stars], 0, 96);
         break;
     case 3:
         if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD)
@@ -1458,9 +1462,9 @@ static bool8 SetTrainerCardBgsAndPals(void)
             LoadPalette(sFireRedTrainerCardBadges_Pal, 48, 32);
         break;
     case 4:
-        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD && sTrainerCardDataPtr->trainerCard.gender != MALE)
+        if (sTrainerCardDataPtr->cardType == CARD_TYPE_EMERALD && sTrainerCardDataPtr->trainerCard.rse.gender != MALE)
             LoadPalette(sEmeraldTrainerCardFemaleBackground_Pal, 16, 32);
-        else if (sTrainerCardDataPtr->trainerCard.gender != MALE)
+        else if (sTrainerCardDataPtr->trainerCard.rse.gender != MALE)
             LoadPalette(sFireRedTrainerCardFemaleBackground_Pal, 16, 32);
         break;
     case 5:
@@ -1525,7 +1529,7 @@ static void TrainerCard_PrintStarsAndBadgesOnCard(void)
     u16 tileNum = 192;
     u8 palNum = 3;
 
-    FillBgTilemapBufferRect(3, 143, 15, sUnknown_83CD95C[sTrainerCardDataPtr->cardType], sTrainerCardDataPtr->trainerCard.stars, 1, 4);
+    FillBgTilemapBufferRect(3, 143, 15, sUnknown_83CD95C[sTrainerCardDataPtr->cardType], sTrainerCardDataPtr->trainerCard.rse.stars, 1, 4);
     if (!sTrainerCardDataPtr->isLink)
     {
         x = 4;
@@ -1590,7 +1594,7 @@ static void sub_808B180(void)
 
 u8 GetTrainerCardStars(u8 cardId)
 {
-    return gTrainerCards[cardId].stars;
+    return gTrainerCards[cardId].rse.stars;
 }
 
 static void sub_808B1D4(void)
@@ -1855,7 +1859,7 @@ static void sub_808B774(void)
 
     for (i = 0; i < 4; i++)
     {
-        CopyEasyChatWord(sTrainerCardDataPtr->var_19[i], sTrainerCardDataPtr->trainerCard.var_28[i]);
+        CopyEasyChatWord(sTrainerCardDataPtr->var_19[i], sTrainerCardDataPtr->trainerCard.rse.var_28[i]);
     }
 }
 
@@ -1879,26 +1883,26 @@ static u8 GetCardType(void)
 
 static void sub_808B838(void)
 {
-    u8 val = sLinkTrainerCardFrontPics[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender];
+    u8 val = sLinkTrainerCardFrontPics[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender];
 
     if (InUnionRoom() == TRUE && gReceivedRemoteLinkPlayers == 1)
     {
         val = sTrainerCardDataPtr->trainerCard.var_4F;
-        sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1], 8, 2);
+        sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1], 8, 2);
     }
     else
     {
         if (sTrainerCardDataPtr->cardType != CARD_TYPE_FRLG)
         {
-            sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1], 8, 2);
+            sub_810C330(FacilityClassToPicIndex(val), TRUE, sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1], 8, 2);
         }
         else
         {
-            sub_810C330(PlayerGenderToFrontTrainerPicId_Debug(sTrainerCardDataPtr->trainerCard.gender, TRUE), TRUE,
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][0],
-                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.gender][1],
+            sub_810C330(PlayerGenderToFrontTrainerPicId_Debug(sTrainerCardDataPtr->trainerCard.rse.gender, TRUE), TRUE,
+                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][0],
+                    sTrainerCardPicPositions[sTrainerCardDataPtr->cardType][sTrainerCardDataPtr->trainerCard.rse.gender][1],
                     8, 2);
         }
     }
diff --git a/src/union_room.c b/src/union_room.c
index f3aeeebc5..40582ef0d 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -4692,23 +4692,23 @@ static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uro
     StringCopy(uroom->trainerCardStrbufs[0], gTrainerClassNames[sub_80447F0()]);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]);
 
-    DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, trainerCard->playerName);
+    DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, trainerCard->rse.playerName);
 
-    StringCopy(uroom->field_174, gUnknown_84594B0[trainerCard->stars]);
+    StringCopy(uroom->field_174, gUnknown_84594B0[trainerCard->rse.stars]);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->field_174);
 
-    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->rse.caughtMonsCount, STR_CONV_MODE_LEFT_ALIGN, 3);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]);
 
-    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[3], trainerCard->playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3);
-    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[4], trainerCard->playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[3], trainerCard->rse.playTimeHours, STR_CONV_MODE_LEFT_ALIGN, 3);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[4], trainerCard->rse.playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(4, uroom->trainerCardStrbufs[3]);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(5, uroom->trainerCardStrbufs[4]);
 
     DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_84594C4);
     StringCopy(gStringVar4, uroom->field_1A4);
 
-    n = trainerCard->linkBattleWins;
+    n = trainerCard->rse.linkBattleWins;
     if (n > 9999)
     {
         n = 9999;
@@ -4716,7 +4716,7 @@ static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uro
     ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[0], n, STR_CONV_MODE_LEFT_ALIGN, 4);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, uroom->trainerCardStrbufs[0]);
 
-    n = trainerCard->linkBattleLosses;
+    n = trainerCard->rse.linkBattleLosses;
     if (n > 9999)
     {
         n = 9999;
@@ -4724,12 +4724,12 @@ static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uro
     ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[1], n, STR_CONV_MODE_LEFT_ALIGN, 4);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(2, uroom->trainerCardStrbufs[1]);
 
-    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5);
+    ConvertIntToDecimalStringN(uroom->trainerCardStrbufs[2], trainerCard->rse.pokemonTrades, STR_CONV_MODE_LEFT_ALIGN, 5);
     DynamicPlaceholderTextUtil_SetPlaceholderPtr(3, uroom->trainerCardStrbufs[2]);
 
     for (i = 0; i < 4; i++)
     {
-        CopyEasyChatWord(uroom->trainerCardStrbufs[i + 3], trainerCard->var_28[i]);
+        CopyEasyChatWord(uroom->trainerCardStrbufs[i + 3], trainerCard->rse.var_28[i]);
         DynamicPlaceholderTextUtil_SetPlaceholderPtr(i + 4, uroom->trainerCardStrbufs[i + 3]);
     }
 
@@ -4743,7 +4743,7 @@ static void ViewURoomPartnerTrainerCard(u8 *unused, struct UnkStruct_URoom * uro
     }
     else if (parent_child == MODE_CHILD)
     {
-        DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459580[trainerCard->gender]);
+        DynamicPlaceholderTextUtil_ExpandPlaceholders(uroom->field_1A4, gUnknown_8459580[trainerCard->rse.gender]);
         StringAppend(gStringVar4, uroom->field_1A4);
     }
 }
-- 
cgit v1.2.3


From 21dddd57605cf4cbc31f0a903cc50a8f588817ff Mon Sep 17 00:00:00 2001
From: PikalaxALT <PikalaxALT@gmail.com>
Date: Sat, 29 Feb 2020 16:31:57 -0500
Subject: Finish cable_club.c

---
 src/cable_club.c | 579 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 573 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/cable_club.c b/src/cable_club.c
index 348a2a83d..246e08a3b 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -1,16 +1,32 @@
 #include "global.h"
 #include "gflib.h"
+#include "battle.h"
+#include "battle_records.h"
+#include "cable_club.h"
 #include "event_data.h"
 #include "event_scripts.h"
 #include "field_message_box.h"
+#include "field_weather.h"
 #include "link.h"
-#include "overworld.h"
+#include "load_save.h"
+#include "m4a.h"
+#include "mevent.h"
 #include "new_menu_helpers.h"
+#include "overworld.h"
+#include "quest_log.h"
 #include "script.h"
+#include "script_pokemon_util.h"
+#include "start_menu.h"
 #include "strings.h"
 #include "task.h"
+#include "trade.h"
 #include "trainer_card.h"
+#include "union_room.h"
 #include "constants/songs.h"
+#include "constants/cable_club.h"
+#include "constants/field_weather.h"
+
+u32 UnusedVarNeededToMatch;
 
 void sub_80809F8(u8 taskId);
 void sub_8080A4C(u8 taskId);
@@ -25,6 +41,10 @@ void sub_8080F78(u8 taskId);
 void sub_8080FB4(u8 taskId);
 void sub_8080FF0(u8 taskId);
 bool8 sub_808102C(u8 taskId);
+void sub_80811FC(u8 taskId);
+void sub_808124C(u8 taskId);
+void sub_80812A0(u8 taskId);
+void sub_80812D8(u8 taskId);
 
 static const struct WindowTemplate gUnknown_83C6AB0 = {
     .bg = 0,
@@ -43,14 +63,14 @@ const u8 *const gUnknown_83C6AB8[] = {
     gUnknown_841DFA0
 };
 
-void sub_8080748(u8 a0, u8 a1)
+void sub_8080748(u8 lower, u8 higher)
 {
     u8 taskId;
     if (FindTaskIdByFunc(sub_80809F8) == 0xFF)
     {
         taskId = CreateTask(sub_80809F8, 80);
-        gTasks[taskId].data[1] = a0;
-        gTasks[taskId].data[2] = a1;
+        gTasks[taskId].data[1] = lower;
+        gTasks[taskId].data[2] = higher;
     }
 }
 
@@ -382,8 +402,8 @@ void sub_8080E6C(u8 taskId)
         if (gSpecialVar_Result == 1)
         {
             // Dumb trick required to match
-            if (gLinkType == 0x4411)
-                gFieldLinkPlayerCount += 0;
+            if (gLinkType == LINKTYPE_0x4411)
+                UnusedVarNeededToMatch += 0;
             sub_80807E8(gTasks[taskId].data[5]);
             EnableBothScriptContexts();
             DestroyTask(taskId);
@@ -395,3 +415,550 @@ void sub_8080E6C(u8 taskId)
         }
     }
 }
+
+void sub_8080F78(u8 taskId)
+{
+    if (!gReceivedRemoteLinkPlayers)
+    {
+        sub_80807E8(gTasks[taskId].data[5]);
+        EnableBothScriptContexts();
+        RemoveWindow(gTasks[taskId].data[5]);
+        DestroyTask(taskId);
+    }
+}
+
+void sub_8080FB4(u8 taskId)
+{
+    gSpecialVar_Result = 5;
+    sub_80807E8(gTasks[taskId].data[5]);
+    HideFieldMessageBox();
+    EnableBothScriptContexts();
+    DestroyTask(taskId);
+}
+
+void sub_8080FF0(u8 taskId)
+{
+    gSpecialVar_Result = 6;
+    sub_80807E8(gTasks[taskId].data[5]);
+    HideFieldMessageBox();
+    EnableBothScriptContexts();
+    DestroyTask(taskId);
+}
+
+bool8 sub_808102C(u8 taskId)
+{
+    gTasks[taskId].data[4]++;
+    if (gTasks[taskId].data[4] > 600)
+    {
+        gTasks[taskId].func = sub_8080FF0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void TryBattleLinkup(void)
+{
+    u8 lower, higher;
+    higher = lower = 2;
+    switch (gSpecialVar_0x8004)
+    {
+    case USING_SINGLE_BATTLE:
+        higher = lower = 2;
+        gLinkType = LINKTYPE_SINGLE_BATTLE;
+        break;
+    case USING_DOUBLE_BATTLE:
+        higher = lower = 2;
+        gLinkType = LINKTYPE_DOUBLE_BATTLE;
+        break;
+    case USING_MULTI_BATTLE:
+        higher = lower = 4;
+        gLinkType = LINKTYPE_MULTI_BATTLE;
+        break;
+    }
+    sub_8080748(lower, higher);
+}
+
+void TryTradeLinkup(void)
+{
+    gLinkType = LINKTYPE_0x1133;
+    gBattleTypeFlags = 0;
+    sub_8080748(2, 2);
+}
+
+void TryRecordMixLinkup(void)
+{
+    gSpecialVar_Result = 0;
+    gLinkType = LINKTYPE_0x3311;
+    gBattleTypeFlags = 0;
+    sub_8080748(2, 4);
+}
+
+void sub_8081128(void)
+{
+    gLinkType = LINKTYPE_0x6601;
+    gBattleTypeFlags = 0;
+    sub_8080748(4, 4);
+}
+
+u8 sub_8081150(void)
+{
+    if (FuncIsActiveTask(sub_80811FC))
+        return 0xFF;
+    switch (gSpecialVar_0x8004)
+    {
+    case USING_SINGLE_BATTLE:
+        gLinkType = LINKTYPE_SINGLE_BATTLE;
+        break;
+    case USING_DOUBLE_BATTLE:
+        gLinkType = LINKTYPE_DOUBLE_BATTLE;
+        break;
+    case USING_MULTI_BATTLE:
+        gLinkType = LINKTYPE_MULTI_BATTLE;
+        break;
+    case USING_TRADE_CENTER:
+        gLinkType = LINKTYPE_0x1111;
+        break;
+    case USING_RECORD_CORNER:
+        gLinkType = LINKTYPE_0x3322;
+        break;
+    }
+    return CreateTask(sub_80811FC, 80);
+}
+
+void sub_80811FC(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    if (data[0] == 0)
+    {
+        OpenLink();
+        ResetLinkPlayers();
+        CreateTask(sub_8081A90, 80);
+    }
+    else if (data[0] > 9)
+        gTasks[taskId].func = sub_808124C;
+    data[0]++;
+}
+
+void sub_808124C(u8 taskId)
+{
+    if (GetLinkPlayerCount_2() >= 2)
+    {
+        if (IsLinkMaster() == TRUE)
+        {
+            gTasks[taskId].func = sub_80812A0;
+        }
+        else
+        {
+            gTasks[taskId].func = sub_80812D8;
+        }
+    }
+}
+
+void sub_80812A0(u8 taskId)
+{
+    if (GetSavedPlayerCount() == GetLinkPlayerCount_2())
+    {
+        CheckShouldAdvanceLinkState();
+        gTasks[taskId].func = sub_80812D8;
+    }
+}
+
+void sub_80812D8(u8 taskId)
+{
+    if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE)
+    {
+        sub_800A9A4();
+        sub_8009FE8();
+        DestroyTask(taskId);
+    }
+}
+
+void sub_808130C(void)
+{
+    Field_AskSaveTheGame();
+}
+
+void sub_8081318(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        FadeScreen(FADE_TO_BLACK, 0);
+        gLinkType = LINKTYPE_BATTLE;
+        ClearLinkCallback_2();
+        task->data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            task->data[0]++;
+        break;
+    case 2:
+        task->data[1]++;
+        if (task->data[1] > 20)
+            task->data[0]++;
+        break;
+    case 3:
+        Link_TryStartSend5FFF();
+        task->data[0]++;
+        break;
+    case 4:
+        if (!gReceivedRemoteLinkPlayers)
+            task->data[0]++;
+        break;
+    case 5:
+        if (gLinkPlayers[0].trainerId & 1)
+            PlayMapChosenOrBattleBGM(MUS_BATTLE32);
+        else
+            PlayMapChosenOrBattleBGM(MUS_BATTLE20);
+        switch (gSpecialVar_0x8004)
+        {
+        case USING_SINGLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK;
+            break;
+        case USING_DOUBLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE;
+            break;
+        case USING_MULTI_BATTLE:
+            ReducePlayerPartyToThree();
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI;
+            break;
+        }
+        CleanupOverworldWindowsAndTilemaps();
+        gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
+        SetMainCallback2(CB2_InitBattle);
+        gMain.savedCallback = sub_8081668;
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+void sub_8081454(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    int i;
+    switch (data[0])
+    {
+    case 0:
+        FadeScreen(FADE_TO_BLACK, 0);
+        gLinkType = LINKTYPE_BATTLE;
+        ClearLinkCallback_2();
+        data[0] = 1;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            data[0] = 2;
+        break;
+    case 2:
+        SendBlock(0, &gLocalLinkPlayer, sizeof(struct LinkPlayer));
+        data[0] = 3;
+        break;
+    case 3:
+        if (GetBlockReceivedStatus() == sub_800A8D4())
+        {
+            for (i = 0; i < GetLinkPlayerCount(); i++)
+            {
+                gLinkPlayers[i] = *(struct LinkPlayer *)gBlockRecvBuffer[i];
+                IntlConvertLinkPlayerName(&gLinkPlayers[i]);
+                ResetBlockReceivedFlag(i);
+            }
+            data[0] = 4;
+        }
+        break;
+    case 4:
+        data[1]++;
+        if (data[1] > 20)
+            data[0] = 5;
+        break;
+    case 5:
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
+        data[0] = 6;
+        break;
+    case 6:
+        if (IsLinkTaskFinished())
+            data[0] = 7;
+        break;
+    case 7:
+        if (gLinkPlayers[0].trainerId & 1)
+            PlayMapChosenOrBattleBGM(MUS_BATTLE32);
+        else
+            PlayMapChosenOrBattleBGM(MUS_BATTLE20);
+        gLinkPlayers[0].linkType = LINKTYPE_BATTLE;
+        switch (gSpecialVar_0x8004)
+        {
+        case USING_SINGLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK;
+            break;
+        case USING_DOUBLE_BATTLE:
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE;
+            break;
+        case USING_MULTI_BATTLE:
+            ReducePlayerPartyToThree();
+            gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_MULTI;
+            break;
+        }
+        CleanupOverworldWindowsAndTilemaps();
+        gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
+        SetMainCallback2(CB2_InitBattle);
+        gMain.savedCallback = sub_8081668;
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+void sub_8081624(void)
+{
+    switch (gMain.state)
+    {
+    case 0:
+        Link_TryStartSend5FFF();
+        gMain.state++;
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+            SetMainCallback2(CB2_ReturnToField);
+        break;
+    }
+}
+
+void sub_8081668(void)
+{
+    gBattleTypeFlags &= (u16)~BATTLE_TYPE_20;
+    sub_8055DB8();
+    LoadPlayerParty();
+    SavePlayerBag();
+    Special_UpdateTrainerFansAfterLinkBattle();
+    if (gSpecialVar_0x8004 != USING_MULTI_BATTLE)
+    {
+        TryRecordLinkBattleOutcome(gLocalLinkPlayerId ^ 1);
+        if (gWirelessCommType != 0)
+        {
+            switch (gBattleOutcome)
+            {
+            case B_OUTCOME_WON:
+                MEvent_RecordIdOfWonderCardSenderByEventType(0, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
+                break;
+            case B_OUTCOME_LOST:
+                MEvent_RecordIdOfWonderCardSenderByEventType(1, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId);
+                break;
+            }
+        }
+    }
+    if (InUnionRoom() == TRUE)
+    {
+        gMain.savedCallback = sub_8081624;
+    }
+    else
+    {
+        gMain.savedCallback = c2_8056854;
+    }
+    SetMainCallback2(CB2_SetUpSaveAfterLinkBattle);
+}
+
+void CleanupLinkRoomState(void)
+{
+    if (gSpecialVar_0x8004 == USING_SINGLE_BATTLE || gSpecialVar_0x8004 == USING_DOUBLE_BATTLE || gSpecialVar_0x8004 == USING_MULTI_BATTLE)
+    {
+        LoadPlayerParty();
+        SavePlayerBag();
+    }
+    copy_saved_warp2_bank_and_enter_x_to_warp1(127);
+}
+
+void sub_8081770(void)
+{
+    sub_8057F5C();
+}
+
+void sub_808177C(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        ShowFieldMessage(CableClub_Text_PleaseWaitBCancel);
+        task->data[0] = 1;
+        break;
+    case 1:
+        if (IsFieldMessageBoxHidden())
+        {
+            sub_8057F34();
+            SetLocalLinkPlayerId(gSpecialVar_0x8005);
+            task->data[0] = 2;
+        }
+        break;
+    case 2:
+        switch (sub_8057EC0())
+        {
+        case 0:
+            break;
+        case 1:
+            HideFieldMessageBox();
+            task->data[0] = 0;
+            sub_8057F70();
+            SwitchTaskToFollowupFunc(taskId);
+            break;
+        case 2:
+            task->data[0] = 3;
+            break;
+        }
+        break;
+    case 3:
+        sub_8057F48();
+        sub_80F771C(TRUE);
+        DestroyTask(taskId);
+        EnableBothScriptContexts();
+        break;
+    }
+}
+
+void sub_8081828(TaskFunc followUpFunc)
+{
+    u8 taskId = CreateTask(sub_808177C, 80);
+    SetTaskFuncWithFollowupFunc(taskId, sub_808177C, followUpFunc);
+    ScriptContext1_Stop();
+}
+
+void sub_8081850(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        ScriptContext2_Enable();
+        FadeScreen(FADE_TO_BLACK, 0);
+        ClearLinkCallback_2();
+        task->data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            task->data[0]++;
+        break;
+    case 2:
+        gSelectedTradeMonPositions[0] = 0;
+        gSelectedTradeMonPositions[1] = 0;
+        m4aMPlayAllStop();
+        Link_TryStartSend5FFF();
+        task->data[0]++;
+        break;
+    case 3:
+        if (!gReceivedRemoteLinkPlayers)
+        {
+            SetMainCallback2(CB2_ReturnFromLinkTrade);
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+void sub_80818E8(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    switch (data[0])
+    {
+    case 0:
+        ScriptContext2_Enable();
+        FadeScreen(FADE_TO_BLACK, 0);
+        Rfu_set_zero();
+        data[0]++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            data[0]++;
+        break;
+    case 2:
+        gSelectedTradeMonPositions[0] = 0;
+        gSelectedTradeMonPositions[1] = 0;
+        m4aMPlayAllStop();
+        PrepareSendLinkCmd2FFE_or_RfuCmd6600();
+        data[0]++;
+        break;
+    case 3:
+        if (IsLinkTaskFinished())
+        {
+            UnionRoom_CreateTask_CallBC2ReturnFromLinkTrade();
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+void EnterTradeSeat(void)
+{
+    if (gWirelessCommType)
+        sub_8081828(sub_80818E8);
+    else
+        sub_8081828(sub_8081850);
+}
+
+void sub_80819A4(void)
+{
+    CreateTask(sub_8081850, 80);
+}
+
+void sub_80819B8(void)
+{
+    sub_80819A4();
+    ScriptContext1_Stop();
+}
+
+void EnterColosseumPlayerSpot(void)
+{
+    gLinkType = LINKTYPE_BATTLE;
+    if (gWirelessCommType)
+        sub_8081828(sub_8081454);
+    else
+        sub_8081828(sub_8081318);
+}
+
+void sub_8081A04(void)
+{
+    CreateTask(sub_808177C, 80);
+    ScriptContext1_Stop();
+}
+
+void Script_ShowLinkTrainerCard(void)
+{
+    ShowTrainerCardInLink(gSpecialVar_0x8006, CB2_ReturnToFieldContinueScriptPlayMapMusic);
+}
+
+bool32 sub_8081A34(u8 who)
+{
+    u8 stars;
+    gSpecialVar_0x8006 = who;
+    StringCopy(gStringVar1, gLinkPlayers[who].name);
+    stars = GetTrainerCardStars(who);
+    if (stars == 0)
+        return FALSE;
+    StringCopy(gStringVar2, gUnknown_83C6AB8[stars - 1]);
+    return TRUE;
+}
+
+void sub_8081A90(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+    task->data[0]++;
+    if (task->data[0] > 300)
+    {
+        CloseLink();
+        SetMainCallback2(CB2_LinkError);
+        DestroyTask(taskId);
+    }
+    if (gReceivedRemoteLinkPlayers)
+        DestroyTask(taskId);
+}
+
+void sub_8081AE4(u8 taskId)
+{
+    if (!gReceivedRemoteLinkPlayers)
+    {
+        EnableBothScriptContexts();
+        DestroyTask(taskId);
+    }
+}
+
+void sub_8081B08(u8 taskId)
+{
+    Link_TryStartSend5FFF();
+    gTasks[taskId].func = sub_8081AE4;
+}
-- 
cgit v1.2.3


From 13687bb97fe2332c7d81059a2cbee42a4905da15 Mon Sep 17 00:00:00 2001
From: PikalaxALT <PikalaxALT@gmail.com>
Date: Sat, 29 Feb 2020 16:35:23 -0500
Subject: Static symbols in cable_club.c

---
 src/cable_club.c | 114 +++++++++++++++++++++++++++----------------------------
 1 file changed, 57 insertions(+), 57 deletions(-)

(limited to 'src')

diff --git a/src/cable_club.c b/src/cable_club.c
index 246e08a3b..1762366a7 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -28,23 +28,23 @@
 
 u32 UnusedVarNeededToMatch;
 
-void sub_80809F8(u8 taskId);
-void sub_8080A4C(u8 taskId);
-void sub_8080AD0(u8 taskId);
-void sub_8080B20(u8 taskId);
-void sub_8080BC8(u8 taskId);
-void sub_8080C6C(u8 taskId);
-void sub_8080CDC(u8 taskId);
-void sub_8080DC0(u8 taskId);
-void sub_8080E6C(u8 taskId);
-void sub_8080F78(u8 taskId);
-void sub_8080FB4(u8 taskId);
-void sub_8080FF0(u8 taskId);
-bool8 sub_808102C(u8 taskId);
-void sub_80811FC(u8 taskId);
-void sub_808124C(u8 taskId);
-void sub_80812A0(u8 taskId);
-void sub_80812D8(u8 taskId);
+static void sub_80809F8(u8 taskId);
+static void sub_8080A4C(u8 taskId);
+static void sub_8080AD0(u8 taskId);
+static void sub_8080B20(u8 taskId);
+static void sub_8080BC8(u8 taskId);
+static void sub_8080C6C(u8 taskId);
+static void sub_8080CDC(u8 taskId);
+static void sub_8080DC0(u8 taskId);
+static void sub_8080E6C(u8 taskId);
+static void sub_8080F78(u8 taskId);
+static void sub_8080FB4(u8 taskId);
+static void sub_8080FF0(u8 taskId);
+static bool8 sub_808102C(u8 taskId);
+static void sub_80811FC(u8 taskId);
+static void sub_808124C(u8 taskId);
+static void sub_80812A0(u8 taskId);
+static void sub_80812D8(u8 taskId);
 
 static const struct WindowTemplate gUnknown_83C6AB0 = {
     .bg = 0,
@@ -56,14 +56,14 @@ static const struct WindowTemplate gUnknown_83C6AB0 = {
     .baseBlock = 0x125
 };
 
-const u8 *const gUnknown_83C6AB8[] = {
+static const u8 *const gUnknown_83C6AB8[] = {
     gUnknown_841DF8B,
     gUnknown_841DF92,
     gUnknown_841DF99,
     gUnknown_841DFA0
 };
 
-void sub_8080748(u8 lower, u8 higher)
+static void sub_8080748(u8 lower, u8 higher)
 {
     u8 taskId;
     if (FindTaskIdByFunc(sub_80809F8) == 0xFF)
@@ -74,7 +74,7 @@ void sub_8080748(u8 lower, u8 higher)
     }
 }
 
-void sub_808078C(u16 windowId, s32 num)
+static void sub_808078C(u16 windowId, s32 num)
 {
     ConvertIntToDecimalStringN(gStringVar1, num, STR_CONV_MODE_LEFT_ALIGN, 1);
     SetStdWindowBorderStyle(windowId, FALSE);
@@ -83,13 +83,13 @@ void sub_808078C(u16 windowId, s32 num)
     CopyWindowToVram(windowId, 3);
 }
 
-void sub_80807E8(u16 windowId)
+static void sub_80807E8(u16 windowId)
 {
     ClearStdWindowAndFrame(windowId, FALSE);
     CopyWindowToVram(windowId, 3);
 }
 
-void sub_8080808(u8 taskId, u8 num)
+static void sub_8080808(u8 taskId, u8 num)
 {
     s16 *data = gTasks[taskId].data;
     if (num != data[3])
@@ -102,7 +102,7 @@ void sub_8080808(u8 taskId, u8 num)
     }
 }
 
-u16 sub_8080844(u8 lower, u8 higher)
+static u16 sub_8080844(u8 lower, u8 higher)
 {
     switch (GetLinkPlayerDataExchangeStatusTimed(lower, higher))
     {
@@ -122,7 +122,7 @@ u16 sub_8080844(u8 lower, u8 higher)
     }
 }
 
-bool32 sub_80808BC(u8 taskId)
+static bool32 sub_80808BC(u8 taskId)
 {
     if (HasLinkErrorOccurred() == TRUE)
     {
@@ -132,7 +132,7 @@ bool32 sub_80808BC(u8 taskId)
     return FALSE;
 }
 
-bool32 sub_80808F0(u8 taskId)
+static bool32 sub_80808F0(u8 taskId)
 {
     if (JOY_NEW(B_BUTTON) && !IsLinkConnectionEstablished())
     {
@@ -143,7 +143,7 @@ bool32 sub_80808F0(u8 taskId)
     return FALSE;
 }
 
-bool32 sub_808093C(u8 taskId)
+static bool32 sub_808093C(u8 taskId)
 {
     if (IsLinkConnectionEstablished())
     {
@@ -158,7 +158,7 @@ bool32 sub_808093C(u8 taskId)
     return FALSE;
 }
 
-bool32 sub_8080990(u8 taskId)
+static bool32 sub_8080990(u8 taskId)
 {
     if (GetSioMultiSI() == TRUE)
     {
@@ -168,7 +168,7 @@ bool32 sub_8080990(u8 taskId)
     return FALSE;
 }
 
-void sub_80809C4(u8 taskId)
+static void sub_80809C4(u8 taskId)
 {
     gTasks[taskId].data[0]++;
     if (gTasks[taskId].data[0] == 10)
@@ -178,7 +178,7 @@ void sub_80809C4(u8 taskId)
     }
 }
 
-void sub_80809F8(u8 taskId)
+static void sub_80809F8(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     if (data[0] == 0)
@@ -195,7 +195,7 @@ void sub_80809F8(u8 taskId)
     data[0]++;
 }
 
-void sub_8080A4C(u8 taskId)
+static void sub_8080A4C(u8 taskId)
 {
     u8 linkPlayerCount = GetLinkPlayerCount_2();
     if (sub_80808F0(taskId) != TRUE && sub_808093C(taskId) != TRUE && linkPlayerCount >= 2)
@@ -217,7 +217,7 @@ void sub_8080A4C(u8 taskId)
     }
 }
 
-void sub_8080AD0(u8 taskId)
+static void sub_8080AD0(u8 taskId)
 {
     if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
     {
@@ -226,7 +226,7 @@ void sub_8080AD0(u8 taskId)
     }
 }
 
-void sub_8080B20(u8 taskId)
+static void sub_8080B20(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     s32 linkPlayerCount = GetLinkPlayerCount_2();
@@ -244,7 +244,7 @@ void sub_8080B20(u8 taskId)
     }
 }
 
-void sub_8080BC8(u8 taskId)
+static void sub_8080BC8(u8 taskId)
 {
     if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
     {
@@ -267,7 +267,7 @@ void sub_8080BC8(u8 taskId)
     }
 }
 
-void sub_8080C6C(u8 taskId)
+static void sub_8080C6C(u8 taskId)
 {
     u8 lower = gTasks[taskId].data[1];
     u8 higher = gTasks[taskId].data[2];
@@ -288,7 +288,7 @@ void sub_8080C6C(u8 taskId)
     }
 }
 
-void sub_8080CDC(u8 taskId)
+static void sub_8080CDC(u8 taskId)
 {
     u8 lower = gTasks[taskId].data[1];
     u8 higher = gTasks[taskId].data[2];
@@ -323,7 +323,7 @@ void sub_8080CDC(u8 taskId)
     }
 }
 
-bool32 sub_8080D8C(void)
+static bool32 sub_8080D8C(void)
 {
     int i;
     u16 version;
@@ -337,7 +337,7 @@ bool32 sub_8080D8C(void)
     return FALSE;
 }
 
-void sub_8080DC0(u8 taskId)
+static void sub_8080DC0(u8 taskId)
 {
     if (sub_80808BC(taskId) != TRUE)
     {
@@ -374,7 +374,7 @@ void sub_8080DC0(u8 taskId)
     }
 }
 
-void sub_8080E6C(u8 taskId)
+static void sub_8080E6C(u8 taskId)
 {
     u8 i;
     u16 version;
@@ -416,7 +416,7 @@ void sub_8080E6C(u8 taskId)
     }
 }
 
-void sub_8080F78(u8 taskId)
+static void sub_8080F78(u8 taskId)
 {
     if (!gReceivedRemoteLinkPlayers)
     {
@@ -427,7 +427,7 @@ void sub_8080F78(u8 taskId)
     }
 }
 
-void sub_8080FB4(u8 taskId)
+static void sub_8080FB4(u8 taskId)
 {
     gSpecialVar_Result = 5;
     sub_80807E8(gTasks[taskId].data[5]);
@@ -436,7 +436,7 @@ void sub_8080FB4(u8 taskId)
     DestroyTask(taskId);
 }
 
-void sub_8080FF0(u8 taskId)
+static void sub_8080FF0(u8 taskId)
 {
     gSpecialVar_Result = 6;
     sub_80807E8(gTasks[taskId].data[5]);
@@ -445,7 +445,7 @@ void sub_8080FF0(u8 taskId)
     DestroyTask(taskId);
 }
 
-bool8 sub_808102C(u8 taskId)
+static bool8 sub_808102C(u8 taskId)
 {
     gTasks[taskId].data[4]++;
     if (gTasks[taskId].data[4] > 600)
@@ -525,7 +525,7 @@ u8 sub_8081150(void)
     return CreateTask(sub_80811FC, 80);
 }
 
-void sub_80811FC(u8 taskId)
+static void sub_80811FC(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     if (data[0] == 0)
@@ -539,7 +539,7 @@ void sub_80811FC(u8 taskId)
     data[0]++;
 }
 
-void sub_808124C(u8 taskId)
+static void sub_808124C(u8 taskId)
 {
     if (GetLinkPlayerCount_2() >= 2)
     {
@@ -554,7 +554,7 @@ void sub_808124C(u8 taskId)
     }
 }
 
-void sub_80812A0(u8 taskId)
+static void sub_80812A0(u8 taskId)
 {
     if (GetSavedPlayerCount() == GetLinkPlayerCount_2())
     {
@@ -563,7 +563,7 @@ void sub_80812A0(u8 taskId)
     }
 }
 
-void sub_80812D8(u8 taskId)
+static void sub_80812D8(u8 taskId)
 {
     if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE)
     {
@@ -578,7 +578,7 @@ void sub_808130C(void)
     Field_AskSaveTheGame();
 }
 
-void sub_8081318(u8 taskId)
+static void sub_8081318(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -633,7 +633,7 @@ void sub_8081318(u8 taskId)
     }
 }
 
-void sub_8081454(u8 taskId)
+static void sub_8081454(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     int i;
@@ -706,7 +706,7 @@ void sub_8081454(u8 taskId)
     }
 }
 
-void sub_8081624(void)
+static void sub_8081624(void)
 {
     switch (gMain.state)
     {
@@ -770,7 +770,7 @@ void sub_8081770(void)
     sub_8057F5C();
 }
 
-void sub_808177C(u8 taskId)
+static void sub_808177C(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -812,14 +812,14 @@ void sub_808177C(u8 taskId)
     }
 }
 
-void sub_8081828(TaskFunc followUpFunc)
+static void sub_8081828(TaskFunc followUpFunc)
 {
     u8 taskId = CreateTask(sub_808177C, 80);
     SetTaskFuncWithFollowupFunc(taskId, sub_808177C, followUpFunc);
     ScriptContext1_Stop();
 }
 
-void sub_8081850(u8 taskId)
+static void sub_8081850(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -851,7 +851,7 @@ void sub_8081850(u8 taskId)
     }
 }
 
-void sub_80818E8(u8 taskId)
+static void sub_80818E8(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     switch (data[0])
@@ -891,7 +891,7 @@ void EnterTradeSeat(void)
         sub_8081828(sub_8081850);
 }
 
-void sub_80819A4(void)
+static void sub_80819A4(void)
 {
     CreateTask(sub_8081850, 80);
 }
@@ -911,7 +911,7 @@ void EnterColosseumPlayerSpot(void)
         sub_8081828(sub_8081318);
 }
 
-void sub_8081A04(void)
+static void sub_8081A04(void)
 {
     CreateTask(sub_808177C, 80);
     ScriptContext1_Stop();
@@ -948,7 +948,7 @@ void sub_8081A90(u8 taskId)
         DestroyTask(taskId);
 }
 
-void sub_8081AE4(u8 taskId)
+static void sub_8081AE4(u8 taskId)
 {
     if (!gReceivedRemoteLinkPlayers)
     {
@@ -957,7 +957,7 @@ void sub_8081AE4(u8 taskId)
     }
 }
 
-void sub_8081B08(u8 taskId)
+static void sub_8081B08(u8 taskId)
 {
     Link_TryStartSend5FFF();
     gTasks[taskId].func = sub_8081AE4;
-- 
cgit v1.2.3


From cbd380f2bf6738ec9222a2284e9de2297f0dc413 Mon Sep 17 00:00:00 2001
From: PikalaxALT <PikalaxALT@gmail.com>
Date: Sat, 29 Feb 2020 17:01:03 -0500
Subject: Name many functions in cable_club.c

---
 src/cable_club.c           | 220 ++++++++++++++++++++++-----------------------
 src/field_fadetransition.c |   4 +-
 src/union_room.c           |   2 +-
 3 files changed, 113 insertions(+), 113 deletions(-)

(limited to 'src')

diff --git a/src/cable_club.c b/src/cable_club.c
index 1762366a7..c2f87a7a7 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -28,23 +28,23 @@
 
 u32 UnusedVarNeededToMatch;
 
-static void sub_80809F8(u8 taskId);
-static void sub_8080A4C(u8 taskId);
-static void sub_8080AD0(u8 taskId);
-static void sub_8080B20(u8 taskId);
-static void sub_8080BC8(u8 taskId);
-static void sub_8080C6C(u8 taskId);
-static void sub_8080CDC(u8 taskId);
-static void sub_8080DC0(u8 taskId);
-static void sub_8080E6C(u8 taskId);
-static void sub_8080F78(u8 taskId);
-static void sub_8080FB4(u8 taskId);
-static void sub_8080FF0(u8 taskId);
-static bool8 sub_808102C(u8 taskId);
-static void sub_80811FC(u8 taskId);
-static void sub_808124C(u8 taskId);
-static void sub_80812A0(u8 taskId);
-static void sub_80812D8(u8 taskId);
+static void Task_Linkup0(u8 taskId);
+static void Task_Linkup1(u8 taskId);
+static void Task_LinkupMaster_2(u8 taskId);
+static void Task_LinkupMaster_3(u8 taskId);
+static void Task_LinkupMaster_4(u8 taskId);
+static void Task_LinkupMaster_5(u8 taskId);
+static void Task_LinkupSlave_2(u8 taskId);
+static void Task_LinkupMaster_6(u8 taskId);
+static void Task_Linkup_6a(u8 taskId);
+static void Task_Linkup_7(u8 taskId);
+static void Task_Linkup_Canceled(u8 taskId);
+static void Task_Linkup_ErroredOut(u8 taskId);
+static bool8 Task_Linkup_TimedOut(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_0(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_1(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_Master(u8 taskId);
+static void Task_ReestablishLinkInCableClubRoom_2(u8 taskId);
 
 static const struct WindowTemplate gUnknown_83C6AB0 = {
     .bg = 0,
@@ -56,25 +56,25 @@ static const struct WindowTemplate gUnknown_83C6AB0 = {
     .baseBlock = 0x125
 };
 
-static const u8 *const gUnknown_83C6AB8[] = {
+static const u8 *const sStarsMessagePtrs[] = {
     gUnknown_841DF8B,
     gUnknown_841DF92,
     gUnknown_841DF99,
     gUnknown_841DFA0
 };
 
-static void sub_8080748(u8 lower, u8 higher)
+static void CreateLinkupTask(u8 lower, u8 higher)
 {
     u8 taskId;
-    if (FindTaskIdByFunc(sub_80809F8) == 0xFF)
+    if (FindTaskIdByFunc(Task_Linkup0) == 0xFF)
     {
-        taskId = CreateTask(sub_80809F8, 80);
+        taskId = CreateTask(Task_Linkup0, 80);
         gTasks[taskId].data[1] = lower;
         gTasks[taskId].data[2] = higher;
     }
 }
 
-static void sub_808078C(u16 windowId, s32 num)
+static void PrintNewCountOnLinkPlayerCountDisplayWindow(u16 windowId, s32 num)
 {
     ConvertIntToDecimalStringN(gStringVar1, num, STR_CONV_MODE_LEFT_ALIGN, 1);
     SetStdWindowBorderStyle(windowId, FALSE);
@@ -83,21 +83,21 @@ static void sub_808078C(u16 windowId, s32 num)
     CopyWindowToVram(windowId, 3);
 }
 
-static void sub_80807E8(u16 windowId)
+static void DestroyLinkPlayerCountDisplayWindow(u16 windowId)
 {
     ClearStdWindowAndFrame(windowId, FALSE);
     CopyWindowToVram(windowId, 3);
 }
 
-static void sub_8080808(u8 taskId, u8 num)
+static void UpdateLinkPlayerCountDisplay(u8 taskId, u8 num)
 {
     s16 *data = gTasks[taskId].data;
     if (num != data[3])
     {
         if (num < 2)
-            sub_80807E8(data[5]);
+            DestroyLinkPlayerCountDisplayWindow(data[5]);
         else
-            sub_808078C(data[5], num);
+            PrintNewCountOnLinkPlayerCountDisplayWindow(data[5], num);
         data[3] = num;
     }
 }
@@ -126,7 +126,7 @@ static bool32 sub_80808BC(u8 taskId)
 {
     if (HasLinkErrorOccurred() == TRUE)
     {
-        gTasks[taskId].func = sub_8080FF0;
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
         return TRUE;
     }
     return FALSE;
@@ -137,7 +137,7 @@ static bool32 sub_80808F0(u8 taskId)
     if (JOY_NEW(B_BUTTON) && !IsLinkConnectionEstablished())
     {
         gLinkType = 0;
-        gTasks[taskId].func = sub_8080FB4;
+        gTasks[taskId].func = Task_Linkup_Canceled;
         return TRUE;
     }
     return FALSE;
@@ -152,7 +152,7 @@ static bool32 sub_808093C(u8 taskId)
     if (JOY_NEW(B_BUTTON))
     {
         gLinkType = 0;
-        gTasks[taskId].func = sub_8080FB4;
+        gTasks[taskId].func = Task_Linkup_Canceled;
         return TRUE;
     }
     return FALSE;
@@ -162,7 +162,7 @@ static bool32 sub_8080990(u8 taskId)
 {
     if (GetSioMultiSI() == TRUE)
     {
-        gTasks[taskId].func = sub_8080FF0;
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
         return TRUE;
     }
     return FALSE;
@@ -178,7 +178,7 @@ static void sub_80809C4(u8 taskId)
     }
 }
 
-static void sub_80809F8(u8 taskId)
+static void Task_Linkup0(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     if (data[0] == 0)
@@ -190,12 +190,12 @@ static void sub_80809F8(u8 taskId)
     }
     else if (data[0] > 9)
     {
-        gTasks[taskId].func = sub_8080A4C;
+        gTasks[taskId].func = Task_Linkup1;
     }
     data[0]++;
 }
 
-static void sub_8080A4C(u8 taskId)
+static void Task_Linkup1(u8 taskId)
 {
     u8 linkPlayerCount = GetLinkPlayerCount_2();
     if (sub_80808F0(taskId) != TRUE && sub_808093C(taskId) != TRUE && linkPlayerCount >= 2)
@@ -206,89 +206,89 @@ static void sub_8080A4C(u8 taskId)
         {
             PlaySE(SE_PIN);
             ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
-            gTasks[taskId].func = sub_8080AD0;
+            gTasks[taskId].func = Task_LinkupMaster_2;
         }
         else
         {
             PlaySE(SE_BOO);
             ShowFieldAutoScrollMessage(CableClub_Text_AwaitingLinkupBCancel);
-            gTasks[taskId].func = sub_8080CDC;
+            gTasks[taskId].func = Task_LinkupSlave_2;
         }
     }
 }
 
-static void sub_8080AD0(u8 taskId)
+static void Task_LinkupMaster_2(u8 taskId)
 {
     if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
     {
         gTasks[taskId].data[3] = 0;
-        gTasks[taskId].func = sub_8080B20;
+        gTasks[taskId].func = Task_LinkupMaster_3;
     }
 }
 
-static void sub_8080B20(u8 taskId)
+static void Task_LinkupMaster_3(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     s32 linkPlayerCount = GetLinkPlayerCount_2();
     if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE)
     {
-        sub_8080808(taskId, linkPlayerCount);
+        UpdateLinkPlayerCountDisplay(taskId, linkPlayerCount);
         if (JOY_NEW(A_BUTTON) && linkPlayerCount >= data[1])
         {
             sub_800A900(linkPlayerCount);
-            sub_80807E8(data[5]);
+            DestroyLinkPlayerCountDisplayWindow(data[5]);
             ConvertIntToDecimalStringN(gStringVar1, linkPlayerCount, STR_CONV_MODE_LEFT_ALIGN, 1);
             ShowFieldAutoScrollMessage(CableClub_Text_StartLinkWithXPlayersAConfirmBCancel);
-            gTasks[taskId].func = sub_8080BC8;
+            gTasks[taskId].func = Task_LinkupMaster_4;
         }
     }
 }
 
-static void sub_8080BC8(u8 taskId)
+static void Task_LinkupMaster_4(u8 taskId)
 {
     if (sub_80808F0(taskId) != TRUE && sub_8080990(taskId) != TRUE && sub_80808BC(taskId) != TRUE && !textbox_any_visible())
     {
         if (GetSavedPlayerCount() != GetLinkPlayerCount_2())
         {
             ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
-            gTasks[taskId].func = sub_8080AD0;
+            gTasks[taskId].func = Task_LinkupMaster_2;
         }
         else if (JOY_HELD(B_BUTTON))
         {
             ShowFieldAutoScrollMessage(CableClub_Text_WhenAllPlayersReadyAConfirmBCancel);
-            gTasks[taskId].func = sub_8080AD0;
+            gTasks[taskId].func = Task_LinkupMaster_2;
         }
         else if (JOY_HELD(A_BUTTON))
         {
             PlaySE(SE_SELECT);
             CheckShouldAdvanceLinkState();
-            gTasks[taskId].func = sub_8080C6C;
+            gTasks[taskId].func = Task_LinkupMaster_5;
         }
     }
 }
 
-static void sub_8080C6C(u8 taskId)
+static void Task_LinkupMaster_5(u8 taskId)
 {
     u8 lower = gTasks[taskId].data[1];
     u8 higher = gTasks[taskId].data[2];
     u16 *res;
-    if (sub_80808BC(taskId) != TRUE && sub_808102C(taskId) != TRUE)
+    if (sub_80808BC(taskId) != TRUE && Task_Linkup_TimedOut(taskId) != TRUE)
     {
         if (GetLinkPlayerCount_2() != GetSavedPlayerCount())
         {
-            gTasks[taskId].func = sub_8080FF0;
+            gTasks[taskId].func = Task_Linkup_ErroredOut;
         }
         else
         {
             res = &gSpecialVar_Result;
             *res = sub_8080844(lower, higher);
             if (*res)
-                gTasks[taskId].func = sub_8080DC0;
+                gTasks[taskId].func = Task_LinkupMaster_6;
         }
     }
 }
 
-static void sub_8080CDC(u8 taskId)
+static void Task_LinkupSlave_2(u8 taskId)
 {
     u8 lower = gTasks[taskId].data[1];
     u8 higher = gTasks[taskId].data[2];
@@ -303,13 +303,13 @@ static void sub_8080CDC(u8 taskId)
             {
                 Link_TryStartSend5FFF();
                 HideFieldMessageBox();
-                gTasks[taskId].func = sub_8080F78;
+                gTasks[taskId].func = Task_Linkup_7;
             }
             else if (*res == 7 || *res == 9)
             {
                 CloseLink();
                 HideFieldMessageBox();
-                gTasks[taskId].func = sub_8080F78;
+                gTasks[taskId].func = Task_Linkup_7;
             }
             else
             {
@@ -317,13 +317,13 @@ static void sub_8080CDC(u8 taskId)
                 gLocalLinkPlayerId = GetMultiplayerId();
                 sub_800A900(gFieldLinkPlayerCount);
                 TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
-                gTasks[taskId].func = sub_8080E6C;
+                gTasks[taskId].func = Task_Linkup_6a;
             }
         }
     }
 }
 
-static bool32 sub_8080D8C(void)
+static bool32 AnyConnectedPartnersPlayingRS(void)
 {
     int i;
     u16 version;
@@ -337,30 +337,30 @@ static bool32 sub_8080D8C(void)
     return FALSE;
 }
 
-static void sub_8080DC0(u8 taskId)
+static void Task_LinkupMaster_6(u8 taskId)
 {
     if (sub_80808BC(taskId) != TRUE)
     {
         if (gSpecialVar_Result == 4)
         {
-            if (sub_8080D8C() == TRUE)
+            if (AnyConnectedPartnersPlayingRS() == TRUE)
                 CloseLink();
             else
                 Link_TryStartSend5FFF();
             HideFieldMessageBox();
-            gTasks[taskId].func = sub_8080F78;
+            gTasks[taskId].func = Task_Linkup_7;
         }
         else if (gSpecialVar_Result == 3)
         {
             Link_TryStartSend5FFF();
             HideFieldMessageBox();
-            gTasks[taskId].func = sub_8080F78;
+            gTasks[taskId].func = Task_Linkup_7;
         }
         else if (gSpecialVar_Result == 7 || gSpecialVar_Result == 9)
         {
             CloseLink();
             HideFieldMessageBox();
-            gTasks[taskId].func = sub_8080F78;
+            gTasks[taskId].func = Task_Linkup_7;
         }
         else
         {
@@ -368,13 +368,13 @@ static void sub_8080DC0(u8 taskId)
             gLocalLinkPlayerId = GetMultiplayerId();
             sub_800A900(gFieldLinkPlayerCount);
             TrainerCard_GenerateCardForLinkPlayer((void*)gBlockSendBuffer);
-            gTasks[taskId].func = sub_8080E6C;
+            gTasks[taskId].func = Task_Linkup_6a;
             sub_800A474(2);
         }
     }
 }
 
-static void sub_8080E6C(u8 taskId)
+static void Task_Linkup_6a(u8 taskId)
 {
     u8 i;
     u16 version;
@@ -404,53 +404,53 @@ static void sub_8080E6C(u8 taskId)
             // Dumb trick required to match
             if (gLinkType == LINKTYPE_0x4411)
                 UnusedVarNeededToMatch += 0;
-            sub_80807E8(gTasks[taskId].data[5]);
+            DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
             EnableBothScriptContexts();
             DestroyTask(taskId);
         }
         else
         {
             Link_TryStartSend5FFF();
-            gTasks[taskId].func = sub_8080F78;
+            gTasks[taskId].func = Task_Linkup_7;
         }
     }
 }
 
-static void sub_8080F78(u8 taskId)
+static void Task_Linkup_7(u8 taskId)
 {
     if (!gReceivedRemoteLinkPlayers)
     {
-        sub_80807E8(gTasks[taskId].data[5]);
+        DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
         EnableBothScriptContexts();
         RemoveWindow(gTasks[taskId].data[5]);
         DestroyTask(taskId);
     }
 }
 
-static void sub_8080FB4(u8 taskId)
+static void Task_Linkup_Canceled(u8 taskId)
 {
     gSpecialVar_Result = 5;
-    sub_80807E8(gTasks[taskId].data[5]);
+    DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
     HideFieldMessageBox();
     EnableBothScriptContexts();
     DestroyTask(taskId);
 }
 
-static void sub_8080FF0(u8 taskId)
+static void Task_Linkup_ErroredOut(u8 taskId)
 {
     gSpecialVar_Result = 6;
-    sub_80807E8(gTasks[taskId].data[5]);
+    DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
     HideFieldMessageBox();
     EnableBothScriptContexts();
     DestroyTask(taskId);
 }
 
-static bool8 sub_808102C(u8 taskId)
+static bool8 Task_Linkup_TimedOut(u8 taskId)
 {
     gTasks[taskId].data[4]++;
     if (gTasks[taskId].data[4] > 600)
     {
-        gTasks[taskId].func = sub_8080FF0;
+        gTasks[taskId].func = Task_Linkup_ErroredOut;
         return TRUE;
     }
     return FALSE;
@@ -475,14 +475,14 @@ void TryBattleLinkup(void)
         gLinkType = LINKTYPE_MULTI_BATTLE;
         break;
     }
-    sub_8080748(lower, higher);
+    CreateLinkupTask(lower, higher);
 }
 
 void TryTradeLinkup(void)
 {
     gLinkType = LINKTYPE_0x1133;
     gBattleTypeFlags = 0;
-    sub_8080748(2, 2);
+    CreateLinkupTask(2, 2);
 }
 
 void TryRecordMixLinkup(void)
@@ -490,19 +490,19 @@ void TryRecordMixLinkup(void)
     gSpecialVar_Result = 0;
     gLinkType = LINKTYPE_0x3311;
     gBattleTypeFlags = 0;
-    sub_8080748(2, 4);
+    CreateLinkupTask(2, 4);
 }
 
 void sub_8081128(void)
 {
     gLinkType = LINKTYPE_0x6601;
     gBattleTypeFlags = 0;
-    sub_8080748(4, 4);
+    CreateLinkupTask(4, 4);
 }
 
-u8 sub_8081150(void)
+u8 CreateTask_ReestablishLinkInCableClubRoom(void)
 {
-    if (FuncIsActiveTask(sub_80811FC))
+    if (FuncIsActiveTask(Task_ReestablishLinkInCableClubRoom_0))
         return 0xFF;
     switch (gSpecialVar_0x8004)
     {
@@ -522,10 +522,10 @@ u8 sub_8081150(void)
         gLinkType = LINKTYPE_0x3322;
         break;
     }
-    return CreateTask(sub_80811FC, 80);
+    return CreateTask(Task_ReestablishLinkInCableClubRoom_0, 80);
 }
 
-static void sub_80811FC(u8 taskId)
+static void Task_ReestablishLinkInCableClubRoom_0(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     if (data[0] == 0)
@@ -535,35 +535,35 @@ static void sub_80811FC(u8 taskId)
         CreateTask(sub_8081A90, 80);
     }
     else if (data[0] > 9)
-        gTasks[taskId].func = sub_808124C;
+        gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_1;
     data[0]++;
 }
 
-static void sub_808124C(u8 taskId)
+static void Task_ReestablishLinkInCableClubRoom_1(u8 taskId)
 {
     if (GetLinkPlayerCount_2() >= 2)
     {
         if (IsLinkMaster() == TRUE)
         {
-            gTasks[taskId].func = sub_80812A0;
+            gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_Master;
         }
         else
         {
-            gTasks[taskId].func = sub_80812D8;
+            gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_2;
         }
     }
 }
 
-static void sub_80812A0(u8 taskId)
+static void Task_ReestablishLinkInCableClubRoom_Master(u8 taskId)
 {
     if (GetSavedPlayerCount() == GetLinkPlayerCount_2())
     {
         CheckShouldAdvanceLinkState();
-        gTasks[taskId].func = sub_80812D8;
+        gTasks[taskId].func = Task_ReestablishLinkInCableClubRoom_2;
     }
 }
 
-static void sub_80812D8(u8 taskId)
+static void Task_ReestablishLinkInCableClubRoom_2(u8 taskId)
 {
     if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE)
     {
@@ -573,12 +573,12 @@ static void sub_80812D8(u8 taskId)
     }
 }
 
-void sub_808130C(void)
+void Special_CableClub_AskSaveTheGame(void)
 {
     Field_AskSaveTheGame();
 }
 
-static void sub_8081318(u8 taskId)
+static void Task_StartWiredCableClubBattle(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -627,13 +627,13 @@ static void sub_8081318(u8 taskId)
         CleanupOverworldWindowsAndTilemaps();
         gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
         SetMainCallback2(CB2_InitBattle);
-        gMain.savedCallback = sub_8081668;
+        gMain.savedCallback = CB2_ReturnFromCableClubBattle;
         DestroyTask(taskId);
         break;
     }
 }
 
-static void sub_8081454(u8 taskId)
+static void Task_StartWirelessCableClubBattle(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     int i;
@@ -700,7 +700,7 @@ static void sub_8081454(u8 taskId)
         CleanupOverworldWindowsAndTilemaps();
         gTrainerBattleOpponent_A = TRAINER_LINK_OPPONENT;
         SetMainCallback2(CB2_InitBattle);
-        gMain.savedCallback = sub_8081668;
+        gMain.savedCallback = CB2_ReturnFromCableClubBattle;
         DestroyTask(taskId);
         break;
     }
@@ -721,7 +721,7 @@ static void sub_8081624(void)
     }
 }
 
-void sub_8081668(void)
+void CB2_ReturnFromCableClubBattle(void)
 {
     gBattleTypeFlags &= (u16)~BATTLE_TYPE_20;
     sub_8055DB8();
@@ -770,7 +770,7 @@ void sub_8081770(void)
     sub_8057F5C();
 }
 
-static void sub_808177C(u8 taskId)
+static void Task_EnterCableClubSeat(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -812,14 +812,14 @@ static void sub_808177C(u8 taskId)
     }
 }
 
-static void sub_8081828(TaskFunc followUpFunc)
+static void CreateEnterCableClubSeatTaskWithFollowupFunc(TaskFunc followUpFunc)
 {
-    u8 taskId = CreateTask(sub_808177C, 80);
-    SetTaskFuncWithFollowupFunc(taskId, sub_808177C, followUpFunc);
+    u8 taskId = CreateTask(Task_EnterCableClubSeat, 80);
+    SetTaskFuncWithFollowupFunc(taskId, Task_EnterCableClubSeat, followUpFunc);
     ScriptContext1_Stop();
 }
 
-static void sub_8081850(u8 taskId)
+static void Task_StartWiredCableClubTrade(u8 taskId)
 {
     struct Task * task = &gTasks[taskId];
     switch (task->data[0])
@@ -851,7 +851,7 @@ static void sub_8081850(u8 taskId)
     }
 }
 
-static void sub_80818E8(u8 taskId)
+static void Task_StartWirelessCableClubTrade(u8 taskId)
 {
     s16 *data = gTasks[taskId].data;
     switch (data[0])
@@ -886,19 +886,19 @@ static void sub_80818E8(u8 taskId)
 void EnterTradeSeat(void)
 {
     if (gWirelessCommType)
-        sub_8081828(sub_80818E8);
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWirelessCableClubTrade);
     else
-        sub_8081828(sub_8081850);
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWiredCableClubTrade);
 }
 
-static void sub_80819A4(void)
+static void CreateTask_StartWiredCableClubTrade(void)
 {
-    CreateTask(sub_8081850, 80);
+    CreateTask(Task_StartWiredCableClubTrade, 80);
 }
 
-void sub_80819B8(void)
+void Special_WiredCableClubTrade(void)
 {
-    sub_80819A4();
+    CreateTask_StartWiredCableClubTrade();
     ScriptContext1_Stop();
 }
 
@@ -906,14 +906,14 @@ void EnterColosseumPlayerSpot(void)
 {
     gLinkType = LINKTYPE_BATTLE;
     if (gWirelessCommType)
-        sub_8081828(sub_8081454);
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWirelessCableClubBattle);
     else
-        sub_8081828(sub_8081318);
+        CreateEnterCableClubSeatTaskWithFollowupFunc(Task_StartWiredCableClubBattle);
 }
 
-static void sub_8081A04(void)
+static void Debug_CreateTaskEnterCableClubSeat(void)
 {
-    CreateTask(sub_808177C, 80);
+    CreateTask(Task_EnterCableClubSeat, 80);
     ScriptContext1_Stop();
 }
 
@@ -922,7 +922,7 @@ void Script_ShowLinkTrainerCard(void)
     ShowTrainerCardInLink(gSpecialVar_0x8006, CB2_ReturnToFieldContinueScriptPlayMapMusic);
 }
 
-bool32 sub_8081A34(u8 who)
+bool32 GetSeeingLinkPlayerCardMsg(u8 who)
 {
     u8 stars;
     gSpecialVar_0x8006 = who;
@@ -930,7 +930,7 @@ bool32 sub_8081A34(u8 who)
     stars = GetTrainerCardStars(who);
     if (stars == 0)
         return FALSE;
-    StringCopy(gStringVar2, gUnknown_83C6AB8[stars - 1]);
+    StringCopy(gStringVar2, sStarsMessagePtrs[stars - 1]);
     return TRUE;
 }
 
diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c
index 16f691a2d..3118061d8 100644
--- a/src/field_fadetransition.c
+++ b/src/field_fadetransition.c
@@ -172,7 +172,7 @@ static void task_mpl_807DD60(u8 taskId)
     switch (task->data[0])
     {
     case 0:
-        task->data[1] = sub_8081150();
+        task->data[1] = CreateTask_ReestablishLinkInCableClubRoom();
         task->data[0]++;
         break;
     case 1:
@@ -192,7 +192,7 @@ static void task_mpl_807DD60(u8 taskId)
     }
 }
 
-void sub_807DDD0(void)
+void FieldCB_ReturnToFieldWiredLink(void)
 {
     ScriptContext2_Enable();
     Overworld_PlaySpecialMapMusic();
diff --git a/src/union_room.c b/src/union_room.c
index 40582ef0d..03517b408 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -1848,7 +1848,7 @@ void StartUnionRoomBattle(u16 battleFlags)
     gLinkPlayers[0].linkType = LINKTYPE_BATTLE;
     gLinkPlayers[GetMultiplayerId()].id = GetMultiplayerId();
     gLinkPlayers[GetMultiplayerId() ^ 1].id = GetMultiplayerId() ^ 1;
-    gMain.savedCallback = sub_8081668;
+    gMain.savedCallback = CB2_ReturnFromCableClubBattle;
     gBattleTypeFlags = battleFlags;
     PlayBattleBGM();
 }
-- 
cgit v1.2.3


From c36ef94a0dae1e60a8e641aced35ee2084c183eb Mon Sep 17 00:00:00 2001
From: PikalaxALT <PikalaxALT@gmail.com>
Date: Sat, 29 Feb 2020 21:00:31 -0500
Subject: address review comments

---
 src/cable_club.c | 6 +++---
 src/union_room.c | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/cable_club.c b/src/cable_club.c
index c2f87a7a7..e7277ed07 100644
--- a/src/cable_club.c
+++ b/src/cable_club.c
@@ -26,7 +26,7 @@
 #include "constants/cable_club.h"
 #include "constants/field_weather.h"
 
-u32 UnusedVarNeededToMatch;
+u32 UnusedVarNeededToMatch[8];
 
 static void Task_Linkup0(u8 taskId);
 static void Task_Linkup1(u8 taskId);
@@ -403,7 +403,7 @@ static void Task_Linkup_6a(u8 taskId)
         {
             // Dumb trick required to match
             if (gLinkType == LINKTYPE_0x4411)
-                UnusedVarNeededToMatch += 0;
+                *UnusedVarNeededToMatch += 0;
             DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]);
             EnableBothScriptContexts();
             DestroyTask(taskId);
@@ -876,7 +876,7 @@ static void Task_StartWirelessCableClubTrade(u8 taskId)
     case 3:
         if (IsLinkTaskFinished())
         {
-            UnionRoom_CreateTask_CallBC2ReturnFromLinkTrade();
+            UnionRoom_CreateTask_CallCB2ReturnFromLinkTrade();
             DestroyTask(taskId);
         }
         break;
diff --git a/src/union_room.c b/src/union_room.c
index 03517b408..f4169b65b 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -1735,7 +1735,7 @@ static void Task_CallCB2ReturnFromLinkTrade(u8 taskId)
     DestroyTask(taskId);
 }
 
-u8 UnionRoom_CreateTask_CallBC2ReturnFromLinkTrade(void)
+u8 UnionRoom_CreateTask_CallCB2ReturnFromLinkTrade(void)
 {
     u8 taskId = CreateTask(Task_CallCB2ReturnFromLinkTrade, 0);
 
-- 
cgit v1.2.3