cereader_tool and ereader_helpers

5 files changed, 614 insertions, 187 deletions

diff --git a/src/cereader_tool.c b/src/cereader_tool.c
new file mode 100644
index 000000000..1b25f4828
--- /dev/null
+++ b/src/cereader_tool.c
@@ -0,0 +1,88 @@
+#include "global.h"
+#include "util.h"
+#include "save.h"
+#include "malloc.h"
+#include "cereader_tool.h"
+
+u8 sub_815D654(void)
+{
+    return (gSaveBlock1Ptr->unkArray[0].unk9 + 1) % 256;
+}
+
+static bool32 ValidateTrainerTowerTrainer(struct TrainerTowerTrainer * trainer)
+{
+    if (trainer->unk_001 < 1 || trainer->unk_001 > 8)
+        return FALSE;
+    if (trainer->unk_002 > 2)
+        return FALSE;
+    if (CalcByteArraySum((const u8 *)trainer, offsetof(typeof(*trainer), checksum)) != trainer->checksum)
+        return FALSE;
+    return TRUE;
+}
+
+bool32 ValidateTrainerTowerData(struct TrainerTowerData * ttdata)
+{
+    u32 count = ttdata->count;
+    s32 i;
+    if (count < 1 || count > 8)
+        return FALSE;
+    for (i = 0; i < count; i++)
+    {
+        if (!ValidateTrainerTowerTrainer(&ttdata->trainers[i]))
+            return FALSE;
+    }
+    if (CalcByteArraySum((const u8 *)ttdata->trainers, count * sizeof(ttdata->trainers[0])) != ttdata->checksum)
+        return FALSE;
+    return TRUE;
+}
+
+#define SEC30_SIZE  (offsetof(struct TrainerTowerData, trainers[4]))
+#define SEC31_SIZE  (sizeof(struct TrainerTowerData) - SEC30_SIZE)
+
+static bool32 CEReaderTool_SaveTrainerTower_r(struct TrainerTowerData * ttdata, u8 * buffer)
+{
+    AGB_ASSERT_EX(ttdata->dummy == 0, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/cereader_tool.c", 198);
+    AGB_ASSERT_EX(ttdata->id == 0, "C:/WORK/POKeFRLG/src/pm_lgfr_ose/source/cereader_tool.c", 199)
+
+    memset(buffer, 0, 0x1000);
+    memcpy(buffer, ttdata, SEC30_SIZE);
+    buffer[1] = sub_815D654();
+    if (TryWriteSpecialSaveSection(30, buffer) != TRUE)
+        return FALSE;
+    memset(buffer, 0, 0x1000);
+    memcpy(buffer, (u8 *)ttdata + SEC30_SIZE, SEC31_SIZE);
+    if (TryWriteSpecialSaveSection(31, buffer) != TRUE)
+        return FALSE;
+    return TRUE;
+}
+
+bool32 CEReaderTool_SaveTrainerTower(struct TrainerTowerData * ttdata)
+{
+    u8 * buffer = AllocZeroed(0x1000);
+    bool32 result = CEReaderTool_SaveTrainerTower_r(ttdata, buffer);
+    Free(buffer);
+    return result;
+}
+
+static bool32 CEReaderTool_LoadTrainerTower_r(struct TrainerTowerData * ttdata, void * buffer)
+{
+    if (TryCopySpecialSaveSection(30, buffer) != 1)
+        return FALSE;
+    memcpy(ttdata + 0x000, buffer, SEC30_SIZE);
+
+    if (TryCopySpecialSaveSection(31, buffer) != 1)
+        return FALSE;
+    memcpy((u8 *)ttdata + SEC30_SIZE, buffer, SEC31_SIZE);
+
+    if (!ValidateTrainerTowerData(ttdata))
+        return FALSE;
+    return TRUE;
+}
+
+bool32 CEReaderTool_LoadTrainerTower(struct TrainerTowerData * ttdata)
+{
+    void * buffer = AllocZeroed(0x1000);
+    bool32 success = CEReaderTool_LoadTrainerTower_r(ttdata, buffer);
+    Free(buffer);
+    return success;
+}
diff --git a/src/ereader_helpers.c b/src/ereader_helpers.c
new file mode 100644
index 000000000..2a9b9ea71
--- /dev/null
+++ b/src/ereader_helpers.c
@@ -0,0 +1,397 @@
+#include "global.h"
+#include "link.h"
+#include "unk_815c27c.h"
+
+enum {
+    EREADER_XFR_STATE_INIT,
+    EREADER_XFR_STATE_HANDSHAKE,
+    EREADER_XFR_STATE_START,
+    EREADER_XFR_STATE_TRANSFER,
+};
+
+struct SendRecvMgr
+{
+    u8 sendOrRecv;
+    u8 state;
+    u8 field_02;
+    u8 field_03;
+    u8 field_04;
+    u32 * dataptr;
+    int cursor;
+    int size;
+    u32 checksum;
+};
+
+static bool16 DetermineSendRecvState(u8);
+static void SetUpTransferManager(size_t, const void *, void *);
+static void StartTm3(void);
+static void EnableSio(void);
+static void DisableTm3(void);
+static void GetKeyInput(void);
+
+static struct SendRecvMgr sSendRecvMgr;
+static u16 sJoyNewOrRepeated;
+static u16 sJoyNew;
+static u16 sSendRecvStatus;
+static u16 sCounter1;
+static u32 sCounter2;
+static u16 sSavedIme;
+static u16 sSavedIe;
+static u16 sSavedTm3Cnt;
+static u16 sSavedSioCnt;
+static u16 sSavedSioCnt;
+static u16 sSavedRCnt;
+
+int EReader_Send(size_t r6, const void * r5)
+{
+    int result;
+    EReaderHelper_SaveRegsState();
+
+    while (1)
+    {
+        GetKeyInput();
+        if (TEST_BUTTON(sJoyNew, B_BUTTON))
+            gUnknown_3003F84 = 2;
+
+        sSendRecvStatus = EReaderHandleTransfer(1, r6, r5, NULL);
+        if ((sSendRecvStatus & 0x13) == 0x10)
+        {
+            result = 0;
+            break;
+        }
+        else if (sSendRecvStatus & 8)
+        {
+            result = 1;
+            break;
+        }
+        else if (sSendRecvStatus & 4)
+        {
+            result = 2;
+            break;
+        }
+        else
+        {
+            gUnknown_3003F84 = 0;
+            VBlankIntrWait();
+        }
+    }
+
+    CpuFill32(0, &sSendRecvMgr, sizeof(sSendRecvMgr));
+    EReaderHelper_RestoreRegsState();
+    return result;
+}
+
+int EReader_Recv(void * r5)
+{
+    int result;
+    EReaderHelper_SaveRegsState();
+
+    while (1)
+    {
+        GetKeyInput();
+        if (TEST_BUTTON(sJoyNew, B_BUTTON))
+            gUnknown_3003F84 = 2;
+
+        sSendRecvStatus = EReaderHandleTransfer(0, 0, NULL, r5);
+        if ((sSendRecvStatus & 0x13) == 0x10)
+        {
+            result = 0;
+            break;
+        }
+        else if (sSendRecvStatus & 8)
+        {
+            result = 1;
+            break;
+        }
+        else if (sSendRecvStatus & 4)
+        {
+            result = 2;
+            break;
+        }
+        else
+        {
+            gUnknown_3003F84 = 0;
+            VBlankIntrWait();
+        }
+    }
+
+    CpuFill32(0, &sSendRecvMgr, sizeof(sSendRecvMgr));
+    EReaderHelper_RestoreRegsState();
+    return result;
+}
+
+static void CloseSerial(void)
+{
+    REG_IME = 0;
+    REG_IE &= ~(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
+    REG_IME = 1;
+    REG_SIOCNT = 0;
+    REG_TM3CNT_H = 0;
+    REG_IF = INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL;
+}
+
+static void OpenSerialMulti(void)
+{
+    REG_IME = 0;
+    REG_IE &= ~(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
+    REG_IME = 1;
+    REG_RCNT = 0;
+    REG_SIOCNT = SIO_MULTI_MODE;
+    REG_SIOCNT |= SIO_INTR_ENABLE | SIO_115200_BPS;
+    REG_IME = 0;
+    REG_IE |= INTR_FLAG_SERIAL;
+    REG_IME = 1;
+    if (sSendRecvMgr.state == 0)
+        CpuFill32(0, &sSendRecvMgr, sizeof(sSendRecvMgr));
+}
+
+static void OpenSerial32(void)
+{
+    REG_RCNT = 0;
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE;
+    REG_SIOCNT |= SIO_MULTI_SD;
+    gUnknown_3003F84 = 0;
+    sCounter1 = 0;
+    sCounter2 = 0;
+}
+
+u16 EReaderHandleTransfer(u8 mode, size_t size, const void * data, void * recvBuffer)
+{
+    switch (sSendRecvMgr.state)
+    {
+    case 0:
+        OpenSerialMulti();
+        sSendRecvMgr.field_02 = 1;
+        sSendRecvMgr.state = 1;
+        break;
+    case 1:
+        if (DetermineSendRecvState(mode))
+            EnableSio();
+        if (gUnknown_3003F84 == 2)
+        {
+            sSendRecvMgr.field_04 = 2;
+            sSendRecvMgr.state = 6;
+        }
+        break;
+    case 2:
+        OpenSerial32();
+        SetUpTransferManager(size, data, recvBuffer);
+        sSendRecvMgr.state = 3;
+        // fallthrough
+    case 3:
+        if (gUnknown_3003F84 == 2)
+        {
+            sSendRecvMgr.field_04 = 2;
+            sSendRecvMgr.state = 6;
+        }
+        else
+        {
+            sCounter1++;
+            sCounter2++;
+            if (sSendRecvMgr.sendOrRecv == 0 && sCounter2 > 60)
+            {
+                sSendRecvMgr.field_04 = 1;
+                sSendRecvMgr.state = 6;
+            }
+            if (sSendRecvMgr.field_02 != 2)
+            {
+                if (sSendRecvMgr.sendOrRecv != 0 && sCounter1 > 2)
+                {
+                    EnableSio();
+                    sSendRecvMgr.field_02 = 2;
+                }
+                else
+                {
+                    EnableSio();
+                    sSendRecvMgr.field_02 = 2;
+                }
+            }
+        }
+        break;
+    case 4:
+        OpenSerialMulti();
+        sSendRecvMgr.state = 5;
+        break;
+    case 5:
+        if (sSendRecvMgr.sendOrRecv == 1 && sCounter1 > 2)
+            EnableSio();
+        if (++sCounter1 > 60)
+        {
+            sSendRecvMgr.field_04 = 1;
+            sSendRecvMgr.state = 6;
+        }
+        break;
+    case 6:
+        if (sSendRecvMgr.field_02 != 0)
+        {
+            CloseSerial();
+            sSendRecvMgr.field_02 = 0;
+        }
+        break;
+    }
+    return sSendRecvMgr.field_02 | (sSendRecvMgr.field_04 << 2) | (sSendRecvMgr.field_03 << 4);
+}
+
+static bool16 DetermineSendRecvState(u8 mode)
+{
+    bool16 resp;
+    if ((*(vu32 *)REG_ADDR_SIOCNT & (SIO_MULTI_SI | SIO_MULTI_SD)) == SIO_MULTI_SD && mode)
+        resp = sSendRecvMgr.sendOrRecv = TRUE;
+    else
+        resp = sSendRecvMgr.sendOrRecv = FALSE;
+    return resp;
+}
+
+static void SetUpTransferManager(size_t size, const void * data, void * recvBuffer)
+{
+    if (sSendRecvMgr.sendOrRecv)
+    {
+        REG_SIOCNT |= SIO_38400_BPS;
+        sSendRecvMgr.dataptr = (void *)data;
+        REG_SIODATA32 = size;
+        sSendRecvMgr.size = size / 4 + 1;
+        StartTm3();
+    }
+    else
+    {
+        REG_SIOCNT |= SIO_9600_BPS;
+        sSendRecvMgr.dataptr = recvBuffer;
+    }
+}
+
+static void StartTm3(void)
+{
+    REG_TM3CNT_L = -601;
+    REG_TM3CNT_H = TIMER_INTR_ENABLE;
+    REG_IME = 0;
+    REG_IE |= INTR_FLAG_TIMER3;
+    REG_IME = 1;
+}
+
+void EReaderHelper_Timer3Callback(void)
+{
+    DisableTm3();
+    EnableSio();
+}
+
+void EReaderHelper_SerialCallback(void)
+{
+    u16 recv[4];
+    u16 i;
+    u16 cnt1;
+    u16 cnt2;
+    u32 recv32;
+
+    switch (sSendRecvMgr.state)
+    {
+    case 1:
+        REG_SIOMLT_SEND = 0xCCD0;
+        *(u64 *)recv = REG_SIOMLT_RECV;
+        for (i = 0, cnt1 = 0, cnt2 = 0; i < 4; i++)
+        {
+            if (recv[i] == 0xCCD0)
+                cnt1++;
+            else if (recv[i] != 0xFFFF)
+                cnt2++;
+        }
+        if (cnt1 == 2 && cnt2 == 0)
+            sSendRecvMgr.state = 2;
+        break;
+    case 3:
+        recv32 = REG_SIODATA32;
+        if (sSendRecvMgr.cursor == 0 && sSendRecvMgr.sendOrRecv == 0)
+            sSendRecvMgr.size = recv32 / 4 + 1;
+        if (sSendRecvMgr.sendOrRecv == 1)
+        {
+            if (sSendRecvMgr.cursor < sSendRecvMgr.size)
+            {
+                REG_SIODATA32 = sSendRecvMgr.dataptr[sSendRecvMgr.cursor];
+                sSendRecvMgr.checksum += sSendRecvMgr.dataptr[sSendRecvMgr.cursor];
+            }
+            else
+                REG_SIODATA32 = sSendRecvMgr.checksum;
+        }
+        else
+        {
+            if (sSendRecvMgr.cursor > 0 && sSendRecvMgr.cursor < sSendRecvMgr.size + 1)
+            {
+                sSendRecvMgr.dataptr[sSendRecvMgr.cursor - 1] = recv32;
+                sSendRecvMgr.checksum += recv32;
+            }
+            else if (sSendRecvMgr.cursor != 0)
+            {
+                if (sSendRecvMgr.checksum == recv32)
+                    sSendRecvMgr.field_03 = 1;
+                else
+                    sSendRecvMgr.field_03 = 2;
+            }
+            sCounter2 = 0;
+        }
+        sSendRecvMgr.cursor++;
+        if (sSendRecvMgr.cursor < sSendRecvMgr.size + 2)
+        {
+            if (sSendRecvMgr.sendOrRecv != 0)
+                REG_TM3CNT_H |= TIMER_ENABLE;
+            else
+                EnableSio();
+        }
+        else
+        {
+            sSendRecvMgr.state = 4;
+            sCounter1 = 0;
+        }
+        break;
+    case 5:
+        if (sSendRecvMgr.sendOrRecv == 0)
+            REG_SIODATA8 = sSendRecvMgr.field_03;
+        *(vu64 *)recv = REG_SIOMLT_RECV;
+        if (recv[1] == 1 || recv[1] == 2)
+        {
+            if (sSendRecvMgr.sendOrRecv == 1)
+                sSendRecvMgr.field_03 = recv[1];
+            sSendRecvMgr.state = 6;
+        }
+        break;
+    }
+}
+
+static void EnableSio(void)
+{
+    REG_SIOCNT |= SIO_ENABLE;
+}
+
+static void DisableTm3(void)
+{
+    REG_TM3CNT_H &= ~TIMER_ENABLE;
+    REG_TM3CNT_L = -601;
+}
+
+static void GetKeyInput(void)
+{
+    u16 rawKeys = REG_KEYINPUT ^ 0x3FF;
+    sJoyNew = rawKeys & ~sJoyNewOrRepeated;
+    sJoyNewOrRepeated = rawKeys;
+}
+
+void EReaderHelper_SaveRegsState(void)
+{
+    sSavedIme = REG_IME;
+    sSavedIe = REG_IE;
+    sSavedTm3Cnt = REG_TM3CNT_H;
+    sSavedSioCnt = REG_SIOCNT;
+    sSavedRCnt = REG_RCNT;
+}
+
+void EReaderHelper_RestoreRegsState(void)
+{
+    REG_IME = sSavedIme;
+    REG_IE = sSavedIe;
+    REG_TM3CNT_H = sSavedTm3Cnt;
+    REG_SIOCNT = sSavedSioCnt;
+    REG_RCNT = sSavedRCnt;
+}
+
+void EReaderHelper_ClearsSendRecvMgr(void)
+{
+    CpuFill32(0, &sSendRecvMgr, sizeof(sSendRecvMgr));
+}
diff --git a/src/mevent.c b/src/mevent.c
index 4d625987e..fc0c1f2d4 100644
--- a/src/mevent.c
+++ b/src/mevent.c
@@ -28,7 +28,7 @@ struct MEventTaskData1
     u16 t02;
     u16 t04;
     u16 t06;
-    u8 t08;
+    u8 state;
     u8 t09;
     u8 t0A;
     u8 t0B;
@@ -91,46 +91,46 @@ struct MEvent_Str_1 gUnknown_3005ED0;
 
 static EWRAM_DATA bool32 gUnknown_203F3BC = FALSE;
 
-void sub_81435DC(struct MEvent_Str_1 *a0, size_t a1, const void * a2)
+void sub_81435DC(struct MEvent_Str_1 *mgr, size_t size, const void * data)
 {
     vu16 imeBak = REG_IME;
     REG_IME = 0;
-    gIntrTable[1] = sub_815C6D4;
-    gIntrTable[2] = sub_815C6C4;
-    sub_815C8C8();
-    sub_815C960();
+    gIntrTable[1] = EReaderHelper_SerialCallback;
+    gIntrTable[2] = EReaderHelper_Timer3Callback;
+    EReaderHelper_SaveRegsState();
+    EReaderHelper_ClearsSendRecvMgr();
     REG_IE |= INTR_FLAG_VCOUNT;
     REG_IME = imeBak;
-    a0->unk_000 = 0;
-    a0->unk_004 = a1;
-    a0->unk_008 = a2;
+    mgr->status = 0;
+    mgr->size = size;
+    mgr->data = data;
 }
 
 void sub_8143644(struct MEvent_Str_1 *unused)
 {
     vu16 imeBak = REG_IME;
     REG_IME = 0;
-    sub_815C960();
-    sub_815C91C();
+    EReaderHelper_ClearsSendRecvMgr();
+    EReaderHelper_RestoreRegsState();
     RestoreSerialTimer3IntrHandlers();
     REG_IME = imeBak;
 }
 
-u8 sub_8143674(struct MEvent_Str_1 *a0)
+u8 sub_8143674(struct MEvent_Str_1 *mgr)
 {
     u8 resp = 0;
-    a0->unk_000 = sub_815C498(1, a0->unk_004, a0->unk_008, 0);
-    if ((a0->unk_000 & 0x13) == 0x10)
+    mgr->status = EReaderHandleTransfer(1, mgr->size, mgr->data, 0);
+    if ((mgr->status & 0x13) == 0x10)
         resp = 1;
-    if (a0->unk_000 & 8)
+    if (mgr->status & 8)
         resp = 2;
-    if (a0->unk_000 & 4)
+    if (mgr->status & 4)
         resp = 3;
     gUnknown_3003F84 = 0;
     return resp;
 }
 
-void sub_81436BC(void)
+static void ResetTTDataBuffer(void)
 {
     memset(gDecompressionBuffer, 0, 0x2000);
     gLinkType = 0x5502;
@@ -143,7 +143,7 @@ bool32 sub_81436EC(void)
     vu16 imeBak = REG_IME;
     u16 data[4];
     REG_IME = 0;
-    *(u64 *)data = gUnknown_3003FB4;
+    *(u64 *)data = gSioMlt_Recv;
     REG_IME = imeBak;
     if (   data[0] == 0xB9A0
         && data[1] == 0xCCD0
@@ -154,7 +154,7 @@ bool32 sub_81436EC(void)
     return FALSE;
 }
 
-bool32 sub_814374C(void)
+static bool32 IsEReaderConnectionSane(void)
 {
     if (sub_800AA48() && GetLinkPlayerCount_2() == 2)
         return TRUE;
@@ -244,7 +244,7 @@ void task_add_00_ereader(void)
 {
     u8 taskId = CreateTask(sub_8143910, 0);
     struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data;
-    data->t08 = 0;
+    data->state = 0;
     data->t09 = 0;
     data->t0A = 0;
     data->t0B = 0;
@@ -258,12 +258,12 @@ void task_add_00_ereader(void)
     data->t10 = AllocZeroed(sizeof(struct MEvent_Str_2));
 }
 
-void sub_81438E8(u16 *a0)
+static void ResetDelayTimer(u16 *a0)
 {
     *a0 = 0;
 }
 
-bool32 sub_81438F0(u16 * a0, u16 a1)
+static bool32 AdvanceDelayTimerCheckTimeout(u16 * a0, u16 a1)
 {
     if (++(*a0) > a1)
     {
@@ -276,49 +276,49 @@ bool32 sub_81438F0(u16 * a0, u16 a1)
 void sub_8143910(u8 taskId)
 {
     struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data;
-    switch (data->t08)
+    switch (data->state)
     {
         case 0:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE52))
-                data->t08 = 1;
+                data->state = 1;
             break;
         case 1:
-            sub_81436BC();
-            sub_81438E8(&data->t00);
-            data->t08 = 2;
+            ResetTTDataBuffer();
+            ResetDelayTimer(&data->t00);
+            data->state = 2;
             break;
         case 2:
-            if (sub_81438F0(&data->t00, 10))
-                data->t08 = 3;
+            if (AdvanceDelayTimerCheckTimeout(&data->t00, 10))
+                data->state = 3;
             break;
         case 3:
-            if (!sub_814374C())
+            if (!IsEReaderConnectionSane())
             {
                 CloseLink();
-                data->t08 = 4;
+                data->state = 4;
             }
             else
-                data->t08 = 13;
+                data->state = 13;
             break;
         case 4:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE53))
             {
                 AddTextPrinterToWindow1(gUnknown_841DE54);
-                sub_81438E8(&data->t00);
-                data->t08 = 5;
+                ResetDelayTimer(&data->t00);
+                data->state = 5;
             }
             break;
         case 5:
-            if (sub_81438F0(&data->t00, 90))
+            if (AdvanceDelayTimerCheckTimeout(&data->t00, 90))
             {
-                sub_81436BC();
-                data->t08 = 6;
+                ResetTTDataBuffer();
+                data->state = 6;
             }
             else if (JOY_NEW(B_BUTTON))
             {
-                sub_81438E8(&data->t00);
+                ResetDelayTimer(&data->t00);
                 PlaySE(SE_SELECT);
-                data->t08 = 23;
+                data->state = 23;
             }
             break;
         case 6:
@@ -326,64 +326,64 @@ void sub_8143910(u8 taskId)
             {
                 PlaySE(SE_SELECT);
                 CloseLink();
-                sub_81438E8(&data->t00);
-                data->t08 = 23;
+                ResetDelayTimer(&data->t00);
+                data->state = 23;
             }
             else if (GetLinkPlayerCount_2() > 1)
             {
-                sub_81438E8(&data->t00);
+                ResetDelayTimer(&data->t00);
                 CloseLink();
-                data->t08 = 7;
+                data->state = 7;
             }
             else if (sub_81436EC())
             {
                 PlaySE(SE_SELECT);
                 CloseLink();
-                sub_81438E8(&data->t00);
-                data->t08 = 8;
+                ResetDelayTimer(&data->t00);
+                data->state = 8;
             }
-            else if (sub_81438F0(&data->t00, 10))
+            else if (AdvanceDelayTimerCheckTimeout(&data->t00, 10))
             {
                 CloseLink();
-                sub_81436BC();
-                sub_81438E8(&data->t00);
+                ResetTTDataBuffer();
+                ResetDelayTimer(&data->t00);
             }
             break;
         case 7:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7C))
-                data->t08 = 4;
+                data->state = 4;
             break;
         case 8:
             AddTextPrinterToWindow1(gUnknown_841DE95);
             sub_81435DC(&gUnknown_3005ED0, gUnknownSerialData_End - gUnknownSerialData_Start, gUnknownSerialData_Start);
-            data->t08 = 9;
+            data->state = 9;
             break;
         case 9:
             data->t0E = sub_8143674(&gUnknown_3005ED0);
             if (data->t0E != 0)
-                data->t08 = 10;
+                data->state = 10;
             break;
         case 10:
             sub_8143644(&gUnknown_3005ED0);
             if (data->t0E == 3)
-                data->t08 = 20;
+                data->state = 20;
             else if (data->t0E == 1)
             {
-                sub_81438E8(&data->t00);
+                ResetDelayTimer(&data->t00);
                 AddTextPrinterToWindow1(gUnknown_841DE9B);
-                data->t08 = 11;
+                data->state = 11;
             }
             else
-                data->t08 = 0;
+                data->state = 0;
             break;
         case 11:
-            if (sub_81438F0(&data->t00, 840))
-                data->t08 = 12;
+            if (AdvanceDelayTimerCheckTimeout(&data->t00, 840))
+                data->state = 12;
             break;
         case 12:
-            sub_81436BC();
+            ResetTTDataBuffer();
             AddTextPrinterToWindow1(gUnknown_841DE98);
-            data->t08 = 13;
+            data->state = 13;
             break;
         case 13:
             switch (sub_8143770(&data->t09, &data->t00))
@@ -392,21 +392,21 @@ void sub_8143910(u8 taskId)
                     break;
                 case 2:
                     AddTextPrinterToWindow1(gUnknown_841DE95);
-                    data->t08 = 14;
+                    data->state = 14;
                     break;
                 case 1:
                     PlaySE(SE_SELECT);
                     CloseLink();
-                    data->t08 = 23;
+                    data->state = 23;
                     break;
                 case 5:
                     CloseLink();
-                    data->t08 = 21;
+                    data->state = 21;
                     break;
                 case 3:
                 case 4:
                     CloseLink();
-                    data->t08 = 20;
+                    data->state = 20;
                     break;
             }
             break;
@@ -414,65 +414,65 @@ void sub_8143910(u8 taskId)
             if (HasLinkErrorOccurred())
             {
                 CloseLink();
-                data->t08 = 20;
+                data->state = 20;
             }
             else if (GetBlockReceivedStatus())
             {
                 ResetBlockReceivedFlags();
-                data->t08 = 15;
+                data->state = 15;
             }
             break;
         case 15:
-            data->t0E = sub_815D6B4(gDecompressionBuffer);
+            data->t0E = ValidateTrainerTowerData((struct TrainerTowerData *)gDecompressionBuffer);
             sub_800AA80(data->t0E);
-            data->t08 = 16;
+            data->state = 16;
             break;
         case 16:
             if (!gReceivedRemoteLinkPlayers)
             {
                 if (data->t0E == 1)
-                    data->t08 = 17;
+                    data->state = 17;
                 else
-                    data->t08 = 20;
+                    data->state = 20;
             }
             break;
         case 17:
-            if (sub_815D794(gDecompressionBuffer))
+            if (CEReaderTool_SaveTrainerTower((struct TrainerTowerData *)gDecompressionBuffer))
             {
                 AddTextPrinterToWindow1(gUnknown_841DE99);
-                sub_81438E8(&data->t00);
-                data->t08 = 18;
+                ResetDelayTimer(&data->t00);
+                data->state = 18;
             }
             else
-                data->t08 = 22;
+                data->state = 22;
             break;
         case 18:
-            if (sub_81438F0(&data->t00, 120))
+            if (AdvanceDelayTimerCheckTimeout(&data->t00, 120))
             {
                 AddTextPrinterToWindow1(gUnknown_841DE9A);
                 PlayFanfare(258);
-                data->t08 = 19;
+                data->state = 19;
             }
             break;
         case 19:
             if (IsFanfareTaskInactive() &&JOY_NEW(A_BUTTON | B_BUTTON))
-                data->t08 = 26;
+                data->state = 26;
             break;
         case 23:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE7D))
-                data->t08 = 26;
+                data->state = 26;
             break;
         case 20:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE96))
-                data->t08 = 0;
+                data->state = 0;
             break;
         case 21:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE97))
-                data->t08 = 0;
+                data->state = 0;
             break;
         case 22:
             if (MG_PrintTextOnWindow1AndWaitButton(&data->t09, gUnknown_841DE9C))
-                data->t08 = 0;
+                data->state = 0;
             break;
         case 26:
             sub_812B484();
diff --git a/src/save.c b/src/save.c
index 761e3c92d..d3d31a22e 100644
--- a/src/save.c
+++ b/src/save.c
@@ -828,7 +828,7 @@ u32 TryCopySpecialSaveSection(u8 sector, u8* dst)
     return 1;
 }
 
-u32 sub_80DA5E0(u8 sector, u8* src)
+u32 TryWriteSpecialSaveSection(u8 sector, u8* src)
 {
     s32 i;
     s32 size;
diff --git a/src/trainer_tower.c b/src/trainer_tower.c
index a36e93260..46c112030 100644
--- a/src/trainer_tower.c
+++ b/src/trainer_tower.c
@@ -35,45 +35,10 @@ struct UnkStruct_8479D34
     u8 flags3[8];
 };
 
-struct UnkSubstruct_203F458_000C_004
-{
-    /* 0x000 */ u8 unk_000[11];
-    /* 0x00B */ u8 unk_00B;
-    /* 0x00C */ u8 unk_00C;
-    /* 0x00E */ u16 unk_00E[6];
-    /* 0x01A */ u16 unk_01A[6];
-    /* 0x026 */ u16 unk_026[6];
-    /* 0x032 */ u16 unk_032[6];
-    /* 0x040 */ struct BattleTowerPokemon unk_040[PARTY_SIZE];
-}; // size: 328
-
-struct UnkSubstruct_203F458_000C
-{
-    /* 0x000 */ u8 unk_000;
-    /* 0x000 */ u8 unk_001;
-    /* 0x002 */ u8 unk_002;
-    /* 0x003 */ u8 unk_003;
-    /* 0x004 */ struct UnkSubstruct_203F458_000C_004 unk_004[3];
-    /* 0x3DC */ u8 filler_3DC[4];
-};
-
-struct Unk_203F458_Header
-{
-    u8 unk0;
-    u8 unk1;
-    u32 unk4;
-};
-
-struct UnkStruct_203F458_SaveBlock
-{
-    struct Unk_203F458_Header unk_0000;
-    struct UnkSubstruct_203F458_000C unk_0008[8];
-};
-
 struct UnkStruct_203F458
 {
     /* 0x0000 */ u8 unk_0000;
-    /* 0x0004 */ struct UnkStruct_203F458_SaveBlock unk_0004;
+    /* 0x0004 */ struct TrainerTowerData unk_0004;
 };
 
 struct UnkStruct_203F45C
@@ -563,30 +528,7 @@ const u8 gUnknown_847A30E[][3] = {
 };
 
 extern const struct Unk_203F458_Header gUnknown_84827AC;
-extern const struct UnkSubstruct_203F458_000C *const gUnknown_84827B4[][8];
-
-bool32 sub_815D7BC(void * dest, void * buffer)
-{
-    if (TryCopySpecialSaveSection(30, buffer) != 1)
-        return FALSE;
-    memcpy(dest + 0x000, buffer, 0xF88);
-
-    if (TryCopySpecialSaveSection(31, buffer) != 1)
-        return FALSE;
-    memcpy(dest + 0xF88, buffer, 0xF80);
-
-    if (!sub_815D6B4(dest))
-        return FALSE;
-    return TRUE;
-}
-
-bool32 sub_815D80C(void * dest)
-{
-    void * buffer = AllocZeroed(0x1000);
-    bool32 success = sub_815D7BC(dest, buffer);
-    Free(buffer);
-    return success;
-}
+extern const struct TrainerTowerTrainer *const gUnknown_84827B4[][8];
 
 bool32 sub_815D834(void)
 {
@@ -696,23 +638,23 @@ void sub_815DA54(void)
     sub_815DC8C();
     gUnknown_203F45C = AllocZeroed(sizeof(*gUnknown_203F45C));
     r10 = VarGet(VAR_0x4001);
-    StringCopyN(gUnknown_203F45C->unk_00, gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10].unk_000, 11);
+    StringCopyN(gUnknown_203F45C->unk_00, gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10].unk_000, 11);
 
     for (r9 = 0; r9 < 6; r9++)
     {
-        gUnknown_203F45C->unk_0C[r9] = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10].unk_01A[r9];
-        gUnknown_203F45C->unk_18[r9] = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10].unk_026[r9];
+        gUnknown_203F45C->unk_0C[r9] = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10].unk_01A[r9];
+        gUnknown_203F45C->unk_18[r9] = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10].unk_026[r9];
 
-        if (gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002 == 1)
+        if (gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002 == 1)
         {
-            gUnknown_203F45C->unk_24[r9] = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10 + 1].unk_01A[r9];
-            gUnknown_203F45C->unk_30[r9] = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10 + 1].unk_026[r9];
+            gUnknown_203F45C->unk_24[r9] = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10 + 1].unk_01A[r9];
+            gUnknown_203F45C->unk_30[r9] = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10 + 1].unk_026[r9];
         }
     }
 
-    gUnknown_203F45C->unk_3C = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002;
-    gUnknown_203F45C->unk_3D = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10].unk_00B;
-    gUnknown_203F45C->unk_3E = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r10].unk_00C;
+    gUnknown_203F45C->unk_3C = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002;
+    gUnknown_203F45C->unk_3D = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10].unk_00B;
+    gUnknown_203F45C->unk_3E = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r10].unk_00C;
     SetVBlankCounter1Ptr(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk0);
     sub_815DD2C();
 }
@@ -750,12 +692,12 @@ void sub_815DC8C(void) // fakematching
 {
     u32 whichTimer = gSaveBlock1Ptr->unkArrayIdx;
     s32 r4;
-    const struct UnkSubstruct_203F458_000C *const * r7;
+    const struct TrainerTowerTrainer *const * r7;
 
     gUnknown_203F458 = AllocZeroed(sizeof(*gUnknown_203F458));
     gUnknown_203F458->unk_0000 = gMapHeader.mapDataId - 0x2A;
     if (sub_815D834() == TRUE)
-        sub_815D80C(&gUnknown_203F458->unk_0004);
+        CEReaderTool_LoadTrainerTower(&gUnknown_203F458->unk_0004);
     else
     {
         struct UnkStruct_203F458 * r0_ = gUnknown_203F458;
@@ -767,12 +709,12 @@ void sub_815DC8C(void) // fakematching
         for (r4 = 0; r4 < 8; r4++)
         {
             void * r0 = gUnknown_203F458;
-            r0 = r4 * sizeof(struct UnkSubstruct_203F458_000C) + r0;
-            r0 += offsetof(struct UnkStruct_203F458, unk_0004.unk_0008);
-            memcpy(r0, r7[r4], sizeof(struct UnkSubstruct_203F458_000C));
+            r0 = r4 * sizeof(struct TrainerTowerTrainer) + r0;
+            r0 += offsetof(struct UnkStruct_203F458, unk_0004.trainers);
+            memcpy(r0, r7[r4], sizeof(struct TrainerTowerTrainer));
 //            r0[r4] = *r7[r4];
         }
-        gUnknown_203F458->unk_0004.unk_0000.unk4 = CalcByteArraySum((void *)gUnknown_203F458->unk_0004.unk_0008, sizeof(gUnknown_203F458->unk_0004.unk_0008));
+        gUnknown_203F458->unk_0004.unk4 = CalcByteArraySum((void *)gUnknown_203F458->unk_0004.trainers, sizeof(gUnknown_203F458->unk_0004.trainers));
         sub_815EC0C();
     }
 }
@@ -799,7 +741,7 @@ void sub_815DC8C(void)
                 "\tbne _0815DCD0\n"
                 "\tldr r0, [r4]\n"
                 "\tadds r0, 0x4\n"
-                "\tbl sub_815D80C\n"
+                "\tbl CEReaderTool_LoadTrainerTower\n"
                 "\tb _0815DD18\n"
                 "\t.align 2, 0\n"
                 "_0815DCBC: .4byte gSaveBlock1Ptr\n"
@@ -860,14 +802,14 @@ void sub_815DD2C(void)
 
 void sub_815DD44(void)
 {
-    if (gMapHeader.mapDataId - 0x129 > gUnknown_203F458->unk_0004.unk_0000.unk0)
+    if (gMapHeader.mapDataId - 0x129 > gUnknown_203F458->unk_0004.count)
     {
         gSpecialVar_Result = 3;
         SetCurrentMapLayout(0x132);
     }
     else
     {
-        gSpecialVar_Result = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002;
+        gSpecialVar_Result = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002;
         SetCurrentMapLayout(gUnknown_847A284[gUnknown_203F458->unk_0000][gSpecialVar_Result]);
         sub_815DDB0();
     }
@@ -877,10 +819,10 @@ void sub_815DDB0(void)
 {
     s32 r3, r4;
     u8 r1, r2, r4_;
-    switch (gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002)
+    switch (gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002)
     {
         case 0:
-            r2 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[0].unk_00B;
+            r2 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[0].unk_00B;
             for (r3 = 0; r3 < NELEMS(gUnknown_8479ED8); r3++)
             {
                 if (gUnknown_8479ED8[r3].unk1 == r2)
@@ -893,7 +835,7 @@ void sub_815DDB0(void)
             VarSet(VAR_0x4011, r1);
             break;
         case 1:
-            r2 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[0].unk_00B;
+            r2 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[0].unk_00B;
             for (r3 = 0; r3 < NELEMS(gUnknown_847A024); r3++)
             {
                 if (gUnknown_847A024[r3].unk2 == r2)
@@ -915,7 +857,7 @@ void sub_815DDB0(void)
         case 2:
             for (r4 = 0; r4 < 3; r4++)
             {
-                r2 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_00B;
+                r2 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_00B;
                 for (r3 = 0; r3 < NELEMS(gUnknown_8479ED8); r3++)
                 {
                     if (gUnknown_8479ED8[r3].unk1 == r2)
@@ -962,25 +904,25 @@ void sub_815DF54(void)
 {
     u16 r4 = gSpecialVar_0x8006;
     u8 r1;
-    u8 r5 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002;
+    u8 r5 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002;
     // HOW DO I MATCH THIS CONTROL FLOW?!?!
-    r1 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r5 == 1 ? 0 : r4].unk_00B;
+    r1 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r5 == 1 ? 0 : r4].unk_00B;
     switch (gSpecialVar_0x8005)
     {
         case 2:
             sub_815E068(r5, r1);
-            sub_815DEFC(gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_00E, gStringVar4);
+            sub_815DEFC(gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_00E, gStringVar4);
             break;
         case 3:
             sub_815E068(r5, r1);
-            sub_815DEFC(gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_01A, gStringVar4);
+            sub_815DEFC(gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_01A, gStringVar4);
             break;
         case 4:
             sub_815E068(r5, r1);
-            sub_815DEFC(gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_026, gStringVar4);
+            sub_815DEFC(gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_026, gStringVar4);
             break;
         case 5:
-            sub_815DEFC(gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_032, gStringVar4);
+            sub_815DEFC(gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_032, gStringVar4);
             break;
     }
 }
@@ -1180,7 +1122,7 @@ void sub_815E124(u8 taskId)
 void sub_815E160(void)
 {
     gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_FACTORY;
-    if (gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002 == 1)
+    if (gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002 == 1)
         gBattleTypeFlags |= BATTLE_TYPE_DOUBLE;
     gTrainerBattleOpponent_A = 0;
     sub_815E9FC();
@@ -1192,7 +1134,7 @@ void sub_815E160(void)
 void sub_815E1C0(void)
 {
     if (!gSpecialVar_0x8005)
-        gSpecialVar_Result = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002;
+        gSpecialVar_Result = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002;
 }
 
 void sub_815E1F0(void)
@@ -1203,7 +1145,7 @@ void sub_815E1F0(void)
 void sub_815E218(void)
 {
     u16 mapDataId = gMapHeader.mapDataId;
-    if (mapDataId - 0x12A == gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8 && mapDataId - 0x129 <= gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_001)
+    if (mapDataId - 0x12A == gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk8 && mapDataId - 0x129 <= gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_001)
         gSpecialVar_Result = FALSE;
     else
         gSpecialVar_Result = TRUE;
@@ -1239,7 +1181,7 @@ void sub_815E394(void)
 
 void sub_815E408(void)
 {
-    u16 itemId = gUnknown_847A2B4[gUnknown_203F458->unk_0004.unk_0008->unk_003];
+    u16 itemId = gUnknown_847A2B4[gUnknown_203F458->unk_0004.trainers->unk_003];
     if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0)
         gSpecialVar_Result = 2;
     else if (AddBagItem(itemId, 1) == 1)
@@ -1367,9 +1309,9 @@ void sub_815E8B4(void)
 
 void sub_815E8CC(void)
 {
-    if (gUnknown_203F458->unk_0004.unk_0000.unk0 != gUnknown_203F458->unk_0004.unk_0008[0].unk_001)
+    if (gUnknown_203F458->unk_0004.count != gUnknown_203F458->unk_0004.trainers[0].unk_001)
     {
-        ConvertIntToDecimalStringN(gStringVar1, gUnknown_203F458->unk_0004.unk_0000.unk0, STR_CONV_MODE_LEFT_ALIGN, 1);
+        ConvertIntToDecimalStringN(gStringVar1, gUnknown_203F458->unk_0004.count, STR_CONV_MODE_LEFT_ALIGN, 1);
         gSpecialVar_Result = TRUE;
     }
     else
@@ -1394,7 +1336,7 @@ void sub_815E948(void)
 {
     s32 i;
     u16 var_4001 = VarGet(VAR_0x4001);
-    u8 r1 = gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[var_4001].unk_00B;
+    u8 r1 = gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[var_4001].unk_00B;
 
     for (i = 0; i < NELEMS(gUnknown_847A074); i++)
     {
@@ -1427,29 +1369,29 @@ void sub_815E9FC(void)
 
     ZeroEnemyPartyMons();
 
-    switch (gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_002)
+    switch (gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_002)
     {
         case 0:
         default:
             for (r6 = 0; r6 < 2; r6++)
             {
                 r2 = gUnknown_847A2EE[r5][r6];
-                gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2].level = r9;
-                sub_803E0A4(&gEnemyParty[r6], &gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2]);
+                gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2].level = r9;
+                sub_803E0A4(&gEnemyParty[r6], &gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2]);
             }
             break;
         case 1:
             r2 = gUnknown_847A2FE[r5][0];
-            gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[0].unk_040[r2].level = r9;
-            sub_803E0A4(&gEnemyParty[0], &gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[0].unk_040[r2]);
+            gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[0].unk_040[r2].level = r9;
+            sub_803E0A4(&gEnemyParty[0], &gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[0].unk_040[r2]);
             r2 = gUnknown_847A2FE[r5][1];
-            gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[1].unk_040[r2].level = r9;
-            sub_803E0A4(&gEnemyParty[1], &gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[1].unk_040[r2]);
+            gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[1].unk_040[r2].level = r9;
+            sub_803E0A4(&gEnemyParty[1], &gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[1].unk_040[r2]);
             break;
         case 2:
             r2 = gUnknown_847A30E[r5][r4];
-            gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2].level = r9;
-            sub_803E0A4(&gEnemyParty[0], &gUnknown_203F458->unk_0004.unk_0008[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2]);
+            gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2].level = r9;
+            sub_803E0A4(&gEnemyParty[0], &gUnknown_203F458->unk_0004.trainers[gUnknown_203F458->unk_0000].unk_004[r4].unk_040[r2]);
             break;
     }
 }
@@ -1474,9 +1416,9 @@ static s32 GetPartyMaxLevel(void)
 
 void sub_815EC0C(void)
 {
-    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 != gUnknown_203F458->unk_0004.unk_0000.unk1)
+    if (gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 != gUnknown_203F458->unk_0004.id)
     {
-        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 = gUnknown_203F458->unk_0004.unk_0000.unk1;
+        gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk9 = gUnknown_203F458->unk_0004.id;
         sub_815EDF4(&gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unk4, 215999);
         gSaveBlock1Ptr->unkArray[gSaveBlock1Ptr->unkArrayIdx].unkA_0 = FALSE;
     }