1 files changed, 181 insertions, 173 deletions

diff --git a/src/mevent_client.c b/src/mevent_client.c
index 9a62bf18e..2bcab1e5a 100644
--- a/src/mevent_client.c
+++ b/src/mevent_client.c
@@ -8,284 +8,292 @@
 #include "mystery_event_script.h"
 #include "mevent_client.h"
 
-EWRAM_DATA struct mevent_client * s_mevent_client_ptr = NULL;
+enum {
+    FUNC_INIT,
+    FUNC_DONE,
+    FUNC_RECV,
+    FUNC_SEND,
+    FUNC_RUN,
+    FUNC_WAIT,
+    FUNC_6,
+    FUNC_7,
+};
 
-static void mevent_client_init(struct mevent_client *, u32, u32);
-static u32 mevent_client_exec(struct mevent_client *);
-static void mevent_client_free_resources(struct mevent_client *);
+EWRAM_DATA static struct MysteryGiftClient * sClient = NULL;
 
-extern const struct mevent_client_cmd gUnknown_082F2598[];
+static void MysteryGiftClient_Init(struct MysteryGiftClient *, u32, u32);
+static u32 MysteryGiftClient_CallFunc(struct MysteryGiftClient *);
+static void MysteryGiftClient_Free(struct MysteryGiftClient *);
 
-void mevent_client_do_init(u32 arg)
+extern const struct MysteryGiftClientCmd gUnknown_082F2598[];
+
+void MysteryGiftClient_Create(bool32 isWonderNews)
 {
-    s_mevent_client_ptr = AllocZeroed(sizeof(struct mevent_client));
-    mevent_client_init(s_mevent_client_ptr, 1, 0);
-    s_mevent_client_ptr->unk_4C = arg;
+    sClient = AllocZeroed(sizeof(*sClient));
+    MysteryGiftClient_Init(sClient, 1, 0);
+    sClient->isWonderNews = isWonderNews;
 }
 
-u32 mevent_client_do_exec(u16 * a0)
+u32 MysteryGiftClient_Run(u16 * endVal)
 {
     u32 result;
-    if (s_mevent_client_ptr == NULL)
-        return 6;
-    result = mevent_client_exec(s_mevent_client_ptr);
-    if (result == 6)
+    if (sClient == NULL)
+        return CLI_RET_END;
+    result = MysteryGiftClient_CallFunc(sClient);
+    if (result == CLI_RET_END)
     {
-        *a0 = s_mevent_client_ptr->param;
-        mevent_client_free_resources(s_mevent_client_ptr);
-        Free(s_mevent_client_ptr);
-        s_mevent_client_ptr = NULL;
+        *endVal = sClient->param;
+        MysteryGiftClient_Free(sClient);
+        Free(sClient);
+        sClient = NULL;
     }
     return result;
 }
 
-void mevent_client_inc_flag(void)
+void MysteryGiftClient_AdvanceState(void)
 {
-    s_mevent_client_ptr->flag++;
+    sClient->funcState++;
 }
 
 void * mevent_client_get_buffer(void)
 {
-    return s_mevent_client_ptr->buffer;
+    return sClient->buffer;
 }
 
-void mevent_client_set_param(u32 a0)
+void MysteryGiftClient_SetParam(u32 val)
 {
-    s_mevent_client_ptr->param = a0;
+    sClient->param = val;
 }
 
-static void mevent_client_init(struct mevent_client * svr, u32 sendPlayerNo, u32 recvPlayerNo)
+static void MysteryGiftClient_Init(struct MysteryGiftClient * client, u32 sendPlayerNo, u32 recvPlayerNo)
 {
-    svr->unk_00 = 0;
-    svr->mainseqno = 0;
-    svr->flag = 0;
-    svr->sendBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->cmdBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->buffer = AllocZeroed(0x40);
-    mevent_srv_sub_init(&svr->manager, sendPlayerNo, recvPlayerNo);
+    client->unk_00 = 0;
+    client->funcId = FUNC_INIT;
+    client->funcState = 0;
+    client->sendBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    client->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    client->cmdBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
+    client->buffer = AllocZeroed(0x40);
+    MysteryGiftLink_Init(&client->link, sendPlayerNo, recvPlayerNo);
 }
 
-static void mevent_client_free_resources(struct mevent_client * svr)
+static void MysteryGiftClient_Free(struct MysteryGiftClient * client)
 {
-    Free(svr->sendBuffer);
-    Free(svr->recvBuffer);
-    Free(svr->cmdBuffer);
-    Free(svr->buffer);
+    Free(client->sendBuffer);
+    Free(client->recvBuffer);
+    Free(client->cmdBuffer);
+    Free(client->buffer);
 }
 
-static void mevent_client_jmp_buffer(struct mevent_client * svr)
+static void MysteryGiftClient_CopyRecvScript(struct MysteryGiftClient * client)
 {
-    memcpy(svr->cmdBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
-    svr->cmdidx = 0;
+    memcpy(client->cmdBuffer, client->recvBuffer, ME_SEND_BUF_SIZE);
+    client->cmdidx = 0;
 }
 
-static void mevent_client_send_word(struct mevent_client * svr, u32 ident, u32 word)
+static void MysteryGiftClient_InitSend(struct MysteryGiftClient * client, u32 ident, u32 word)
 {
-    CpuFill32(0, svr->sendBuffer, ME_SEND_BUF_SIZE);
-    *(u32 *)svr->sendBuffer = word;
-    mevent_srv_sub_init_send(&svr->manager, ident, svr->sendBuffer, sizeof(u32));
+    CpuFill32(0, client->sendBuffer, ME_SEND_BUF_SIZE);
+    *(u32 *)client->sendBuffer = word;
+    MysteryGiftLink_InitSend(&client->link, ident, client->sendBuffer, sizeof(u32));
 }
 
-static u32 mainseq_0(struct mevent_client * svr)
+static u32 Client_Init(struct MysteryGiftClient * client)
 {
-    // init
-    memcpy(svr->cmdBuffer, gUnknown_082F2598, ME_SEND_BUF_SIZE);
-    svr->cmdidx = 0;
-    svr->mainseqno = 4;
-    svr->flag = 0;
-    return 0;
+    memcpy(client->cmdBuffer, gUnknown_082F2598, ME_SEND_BUF_SIZE);
+    client->cmdidx = 0;
+    client->funcId = FUNC_RUN;
+    client->funcState = 0;
+    return CLI_RET_INIT;
 }
 
-static u32 mainseq_1(struct mevent_client * svr)
+static u32 Client_Done(struct MysteryGiftClient * client)
 {
-    // done
-    return 6;
+    return CLI_RET_END;
 }
 
 
-static u32 mainseq_2(struct mevent_client * svr)
+static u32 Client_Recv(struct MysteryGiftClient * client)
 {
-    // do recv
-    if (mevent_srv_sub_recv(&svr->manager))
+    if (MysteryGiftLink_Recv(&client->link))
     {
-        svr->mainseqno = 4;
-        svr->flag = 0;
+        client->funcId = FUNC_RUN;
+        client->funcState = 0;
     }
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mainseq_3(struct mevent_client * svr)
+static u32 Client_Send(struct MysteryGiftClient * client)
 {
-    // do send
-    if (mevent_srv_sub_send(&svr->manager))
+    if (MysteryGiftLink_Send(&client->link))
     {
-        svr->mainseqno = 4;
-        svr->flag = 0;
+        client->funcId = FUNC_RUN;
+        client->funcState = 0;
     }
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mainseq_4(struct mevent_client * svr)
+static u32 Client_Run(struct MysteryGiftClient * client)
 {
     // process command
-    struct mevent_client_cmd * cmd = &svr->cmdBuffer[svr->cmdidx];
-    ++svr->cmdidx;
+    struct MysteryGiftClientCmd * cmd = &client->cmdBuffer[client->cmdidx];
+    client->cmdidx++;
     switch (cmd->instr)
     {
-    case 0:
+    case CLI_NONE:
         break;
-    case 1:
-        svr->param = cmd->parameter;
-        svr->mainseqno = 1;
-        svr->flag = 0;
+    case CLI_RETURN:
+        client->param = cmd->parameter; // Set for endVal in MysteryGiftClient_Run
+        client->funcId = FUNC_DONE;
+        client->funcState = 0;
         break;
-    case 2:
-        mevent_srv_sub_init_recv(&svr->manager, cmd->parameter, svr->recvBuffer);
-        svr->mainseqno = 2;
-        svr->flag = 0;
+    case CLI_RECV:
+        MysteryGiftLink_InitRecv(&client->link, cmd->parameter, client->recvBuffer);
+        client->funcId = FUNC_RECV;
+        client->funcState = 0;
         break;
-    case 3:
-        svr->mainseqno = 3;
-        svr->flag = 0;
+    case CLI_SEND_LOADED:
+        // Send without a MysteryGiftLink_InitSend
+        // Sends whatever has been loaded already
+        client->funcId = FUNC_SEND;
+        client->funcState = 0;
         break;
-    case 20:
-        mevent_srv_sub_init_send(&svr->manager, 0x14, svr->sendBuffer, 0);
-        svr->mainseqno = 3;
-        svr->flag = 0;
+    case CLI_20:
+        MysteryGiftLink_InitSend(&client->link, 0x14, client->sendBuffer, 0);
+        client->funcId = FUNC_SEND;
+        client->funcState = 0;
         break;
-    case 19:
-        mevent_client_send_word(svr, 0x12, GetGameStat(cmd->parameter));
-        svr->mainseqno = 3;
-        svr->flag = 0;
+    case CLI_SEND_STAT:
+        MysteryGiftClient_InitSend(client, 0x12, GetGameStat(cmd->parameter));
+        client->funcId = FUNC_SEND;
+        client->funcState = 0;
         break;
-    case 6:
-        if (svr->param == 0)
-            mevent_client_jmp_buffer(svr);
+    case CLI_COPY_RECV_IF_N:
+        if (client->param == FALSE)
+            MysteryGiftClient_CopyRecvScript(client);
         break;
-    case 7:
-        if (svr->param == 1)
-            mevent_client_jmp_buffer(svr);
+    case CLI_COPY_RECV_IF:
+        if (client->param == TRUE)
+            MysteryGiftClient_CopyRecvScript(client);
         break;
-    case 4:
-        mevent_client_jmp_buffer(svr);
+    case CLI_COPY_RECV:
+        MysteryGiftClient_CopyRecvScript(client);
         break;
-    case 5:
-        memcpy(svr->buffer, svr->recvBuffer, 0x40);
-        svr->mainseqno = 5;
-        svr->flag = 0;
-        return 2;
-    case 11:
-        memcpy(svr->buffer, svr->recvBuffer, 0x40);
-        svr->mainseqno = 5;
-        svr->flag = 0;
-        return 3;
-    case 12:
-        memcpy(svr->buffer, svr->recvBuffer, 0x40);
-        svr->mainseqno = 5;
-        svr->flag = 0;
-        return 5;
-    case 13:
-        svr->mainseqno = 5;
-        svr->flag = 0;
-        return 4;
-    case 8:
-        sub_801B580(svr->sendBuffer, svr->unk_4C);
-        mevent_srv_sub_init_send(&svr->manager, 0x11, svr->sendBuffer, sizeof(struct MEventStruct_Unk1442CC));
+    case CLI_5:
+        memcpy(client->buffer, client->recvBuffer, 0x40);
+        client->funcId = FUNC_WAIT;
+        client->funcState = 0;
+        return CLI_RET_2;
+    case CLI_11:
+        memcpy(client->buffer, client->recvBuffer, 0x40);
+        client->funcId = FUNC_WAIT;
+        client->funcState = 0;
+        return CLI_RET_3;
+    case CLI_12:
+        memcpy(client->buffer, client->recvBuffer, 0x40);
+        client->funcId = FUNC_WAIT;
+        client->funcState = 0;
+        return CLI_RET_5;
+    case CLI_ASK_TOSS:
+        client->funcId = FUNC_WAIT;
+        client->funcState = 0;
+        return CLI_RET_ASK_TOSS;
+    case CLI_8:
+        sub_801B580(client->sendBuffer, client->isWonderNews);
+        MysteryGiftLink_InitSend(&client->link, 0x11, client->sendBuffer, sizeof(struct MEventStruct_Unk1442CC));
         break;
-    case 14:
-        mevent_client_send_word(svr, 0x13, svr->param);
+    case CLI_LOAD_TOSS_RESPONSE:
+        // param here is set by MG_STATE_LINK_ASK_TOSS or MG_STATE_LINK_ASK_TOSS_UNRECEIVED
+        MysteryGiftClient_InitSend(client, 0x13, client->param);
         break;
-    case 10:
-        sub_801B21C(svr->recvBuffer);
+    case CLI_10:
+        SaveWonderCard(client->recvBuffer);
         break;
-    case 9:
-        if (!sub_801B1A4(svr->recvBuffer))
+    case CLI_9:
+        if (!sub_801B1A4(client->recvBuffer))
         {
-            sub_801B078(svr->recvBuffer);
-            mevent_client_send_word(svr, 0x13, 0);
+            SaveWonderNews(client->recvBuffer);
+            MysteryGiftClient_InitSend(client, 0x13, 0);
         }
         else
-            mevent_client_send_word(svr, 0x13, 1);
+            MysteryGiftClient_InitSend(client, 0x13, 1);
         break;
-    case 15:
-        svr->mainseqno = 6;
-        svr->flag = 0;
+    case CLI_15:
+        client->funcId = FUNC_6;
+        client->funcState = 0;
         break;
-    case 16:
-        sub_801B508(svr->recvBuffer);
+    case CLI_16:
+        sub_801B508(client->recvBuffer);
         break;
-    case 17:
-        InitRamScript_NoObjectEvent(svr->recvBuffer, 1000);
+    case CLI_17:
+        InitRamScript_NoObjectEvent(client->recvBuffer, 1000);
         break;
-    case 18:
-        memcpy(&gSaveBlock2Ptr->frontier.ereaderTrainer, svr->recvBuffer, 0xbc);
+    case CLI_RECV_EREADER_TRAINER:
+        memcpy(&gSaveBlock2Ptr->frontier.ereaderTrainer, client->recvBuffer, sizeof(gSaveBlock2Ptr->frontier.ereaderTrainer));
         ValidateEReaderTrainer();
         break;
-    case 21:
-        memcpy(gDecompressionBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE);
-        svr->mainseqno = 7;
-        svr->flag = 0;
+    case CLI_21:
+        memcpy(gDecompressionBuffer, client->recvBuffer, ME_SEND_BUF_SIZE);
+        client->funcId = FUNC_7;
+        client->funcState = 0;
         break;
     }
 
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mainseq_5(struct mevent_client * svr)
+static u32 Client_Wait(struct MysteryGiftClient * client)
 {
-    // wait flag
-    if (svr->flag)
+    if (client->funcState)
     {
-        svr->mainseqno = 4;
-        svr->flag = 0;
+        client->funcId = FUNC_RUN;
+        client->funcState = 0;
     }
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mainseq_6(struct mevent_client * svr)
+static u32 Client_6(struct MysteryGiftClient * client)
 {
-    // ???
-    switch (svr->flag)
+    switch (client->funcState)
     {
     case 0:
-        sub_8153870(svr->recvBuffer);
-        ++svr->flag;
+        InitMysteryGiftScriptContext(client->recvBuffer);
+        client->funcState++;
         break;
     case 1:
-        if (!sub_8153884(&svr->param))
+        if (!RunMysteryGiftScriptContextCommand(&client->param))
         {
-            svr->mainseqno = 4;
-            svr->flag = 0;
+            client->funcId = FUNC_RUN;
+            client->funcState = 0;
         }
         break;
     }
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mainseq_7(struct mevent_client * svr)
+static u32 Client_7(struct MysteryGiftClient * client)
 {
     // exec arbitrary code
     u32 (*func)(u32 *, struct SaveBlock2 *, struct SaveBlock1 *) = (void *)gDecompressionBuffer;
-    if (func(&svr->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1)
+    if (func(&client->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1)
     {
-        svr->mainseqno = 4;
-        svr->flag = 0;
+        client->funcId = FUNC_RUN;
+        client->funcState = 0;
     }
-    return 1;
+    return CLI_RET_1;
 }
 
-static u32 mevent_client_exec(struct mevent_client * svr)
+static u32 MysteryGiftClient_CallFunc(struct MysteryGiftClient * client)
 {
-    u32 (*funcs[])(struct mevent_client *) = {
-        mainseq_0,
-        mainseq_1,
-        mainseq_2,
-        mainseq_3,
-        mainseq_4,
-        mainseq_5,
-        mainseq_6,
-        mainseq_7
+    u32 (*funcs[])(struct MysteryGiftClient *) = {
+        [FUNC_INIT] = Client_Init,
+        [FUNC_DONE] = Client_Done,
+        [FUNC_RECV] = Client_Recv,
+        [FUNC_SEND] = Client_Send,
+        [FUNC_RUN]  = Client_Run,
+        [FUNC_WAIT] = Client_Wait,
+        [FUNC_6]    = Client_6,
+        [FUNC_7]    = Client_7
     };
-    return funcs[svr->mainseqno](svr);
+    return funcs[client->funcId](client);
 }