General mystery gift documentation, finish mystery gift client/server/scripts

1 files changed, 179 insertions, 183 deletions

diff --git a/src/mevent_server.c b/src/mevent_server.c
index 1bae6a3e1..5313e02f7 100644
--- a/src/mevent_server.c
+++ b/src/mevent_server.c
@@ -5,291 +5,287 @@
 #include "mevent_server.h"
 #include "mevent_server_helpers.h"
 
-EWRAM_DATA struct mevent_srv_common * s_mevent_srv_common_ptr = NULL;
+enum {
+    FUNC_INIT,
+    FUNC_DONE,
+    FUNC_RECV,
+    FUNC_SEND,
+    FUNC_RUN,
+};
+
+EWRAM_DATA static struct MysteryGiftServer * sServer = NULL;
 
-static void mevent_srv_init_common(struct mevent_srv_common *, const void *, u32, u32);
-static void mevent_srv_free_resources(struct mevent_srv_common *);
-static u32 mevent_srv_exec_common(struct mevent_srv_common *);
+static void MysteryGiftServer_Init(struct MysteryGiftServer *, const void *, u32, u32);
+static void MysteryGiftServer_Free(struct MysteryGiftServer *);
+static u32 MysteryGiftServer_CallFunc(struct MysteryGiftServer *);
 
-extern const struct mevent_cmd s_mevent_wonder_news[];
-extern const struct mevent_cmd s_mevent_wonder_card[];
+extern const struct MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderNews[];
+extern const struct MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderCard[];
 
-void mevent_srv_init_wnews(void)
+void MysterGiftServer_CreateForNews(void)
 {
-    s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common));
-    mevent_srv_init_common(s_mevent_srv_common_ptr, s_mevent_wonder_news, 0, 1);
+    sServer = AllocZeroed(sizeof(*sServer));
+    MysteryGiftServer_Init(sServer, gMysteryGiftServerScript_SendWonderNews, 0, 1);
 }
 
-void mevent_srv_new_wcard(void)
+void MysterGiftServer_CreateForCard(void)
 {
-    s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common));
-    mevent_srv_init_common(s_mevent_srv_common_ptr, s_mevent_wonder_card, 0, 1);
+    sServer = AllocZeroed(sizeof(*sServer));
+    MysteryGiftServer_Init(sServer, gMysteryGiftServerScript_SendWonderCard, 0, 1);
 }
 
-u32 mevent_srv_common_do_exec(u16 * a0)
+u32 MysterGiftServer_Run(u16 * endVal)
 {
     u32 result;
-    if (s_mevent_srv_common_ptr == NULL)
-        return 3;
-    result = mevent_srv_exec_common(s_mevent_srv_common_ptr);
-    if (result == 3)
+    if (sServer == NULL)
+        return SVR_RET_END;
+    result = MysteryGiftServer_CallFunc(sServer);
+    if (result == SVR_RET_END)
     {
-        *a0 = s_mevent_srv_common_ptr->param;
-        mevent_srv_free_resources(s_mevent_srv_common_ptr);
-        Free(s_mevent_srv_common_ptr);
-        s_mevent_srv_common_ptr = NULL;
+        *endVal = sServer->param;
+        MysteryGiftServer_Free(sServer);
+        Free(sServer);
+        sServer = NULL;
     }
     return result;
 }
 
-static void mevent_srv_init_common(struct mevent_srv_common * svr, const void * cmdBuffer, u32 sendPlayerNo, u32 recvPlayerNo)
+static void MysteryGiftServer_Init(struct MysteryGiftServer * svr, const void * script, u32 sendPlayerId, u32 recvPlayerId)
 {
-    svr->unk_00 = 0;
-    svr->mainseqno = 0;
-    svr->wonder_card = AllocZeroed(sizeof(struct WonderCard));
-    svr->wonder_news = AllocZeroed(sizeof(struct WonderNews));
-    svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE);
-    svr->mevent_unk1442cc = AllocZeroed(sizeof(struct MEventStruct_Unk1442CC));
-    svr->cmdBuffer = cmdBuffer;
+    svr->unused = 0;
+    svr->funcId = FUNC_INIT;
+    svr->card = AllocZeroed(sizeof(*svr->card));
+    svr->news = AllocZeroed(sizeof(*svr->news));
+    svr->recvBuffer = AllocZeroed(MG_LINK_BUFFER_SIZE);
+    svr->linkGameData = AllocZeroed(sizeof(*svr->linkGameData));
+    svr->script = script;
     svr->cmdidx = 0;
-    MysteryGiftLink_Init(&svr->manager, sendPlayerNo, recvPlayerNo);
+    MysteryGiftLink_Init(&svr->link, sendPlayerId, recvPlayerId);
 }
 
-static void mevent_srv_free_resources(struct mevent_srv_common * svr)
+static void MysteryGiftServer_Free(struct MysteryGiftServer * svr)
 {
-    Free(svr->wonder_card);
-    Free(svr->wonder_news);
+    Free(svr->card);
+    Free(svr->news);
     Free(svr->recvBuffer);
-    Free(svr->mevent_unk1442cc);
+    Free(svr->linkGameData);
 }
 
-void mevent_srv_common_init_send(struct mevent_srv_common * svr, u32 ident, const void * src, u32 size)
+static void MysteryGiftServer_InitSend(struct MysteryGiftServer * svr, u32 ident, const void * src, u32 size)
 {
-    AGB_ASSERT(size <= ME_SEND_BUF_SIZE);
-    MysteryGiftLink_InitSend(&svr->manager, ident, src, size);
+    AGB_ASSERT(size <= MG_LINK_BUFFER_SIZE);
+    MysteryGiftLink_InitSend(&svr->link, ident, src, size);
 }
 
-static const void * mevent_first_if_not_null_else_second(const void * a0, const void * a1)
+// Given the command pointer parameter and the 'default' normal data.
+// If the command's pointer is not empty use that as the send data, otherwise use the default.
+static const void * MysteryGiftServer_GetSendData(const void * dynamicData, const void * defaultData)
 {
-    if (a0 != NULL)
-        return a0;
+    if (dynamicData != NULL)
+        return dynamicData;
     else
-        return a1;
+        return defaultData;
 }
 
-static u32 mevent_compare_pointers(const void * a0, const void * a1)
+static u32 MysteryGiftServer_Compare(const void * a, const void * b)
 {
-    if (a1 < a0)
+    if (b < a)
         return 0;
-    else if (a1 == a0)
+    else if (b == a)
         return 1;
     else
         return 2;
 }
 
-static u32 common_mainseq_0(struct mevent_srv_common * svr)
+static u32 Server_Init(struct MysteryGiftServer * svr)
 {
-    // start
-    svr->mainseqno = 4;
-    return 0;
+    svr->funcId = FUNC_RUN;
+    return SVR_RET_INIT;
 }
 
-static u32 common_mainseq_1(struct mevent_srv_common * svr)
+static u32 Server_Done(struct MysteryGiftServer * svr)
 {
-    // done
-    return 3;
+    return SVR_RET_END;
 }
 
-static u32 common_mainseq_2(struct mevent_srv_common * svr)
+static u32 Server_Recv(struct MysteryGiftServer * svr)
 {
-    // do recv
-    if (MysteryGiftLink_Recv(&svr->manager))
-        svr->mainseqno = 4;
-    return 1;
+    if (MysteryGiftLink_Recv(&svr->link))
+        svr->funcId = FUNC_RUN;
+    return SVR_RET_ACTIVE;
 }
 
-static u32 common_mainseq_3(struct mevent_srv_common * svr)
+static u32 Server_Send(struct MysteryGiftServer * svr)
 {
-    // do send
-    if (MysteryGiftLink_Send(&svr->manager))
-        svr->mainseqno = 4;
-    return 1;
+    if (MysteryGiftLink_Send(&svr->link))
+        svr->funcId = FUNC_RUN;
+    return SVR_RET_ACTIVE;
 }
 
-static u32 common_mainseq_4(struct mevent_srv_common * svr)
+static u32 Server_Run(struct MysteryGiftServer * svr)
 {
     // process command
-    const struct mevent_cmd * cmd = &svr->cmdBuffer[svr->cmdidx];
+    const struct MysteryGiftServerCmd * cmd = &svr->script[svr->cmdidx];
     const void * ptr;
     svr->cmdidx++;
 
     switch (cmd->instr)
     {
-    case 0:
-        // end
-        AGB_ASSERT(cmd->parameter == NULL);
-        svr->mainseqno = 1;
-        svr->param = cmd->flag;
+    case SVR_RETURN:
+        AGB_ASSERT(cmd->ptr == NULL);
+        svr->funcId = FUNC_DONE;
+        svr->param = cmd->parameter; // Set for endVal in MysteryGiftServer_Run
         break;
-    case 1:
-        // wait_send
-        svr->mainseqno = 3;
+    case SVR_SEND:
+        svr->funcId = FUNC_SEND;
         break;
-    case 2:
-        // receive
-        AGB_ASSERT(cmd->parameter == NULL);
-        MysteryGiftLink_InitRecv(&svr->manager, cmd->flag, svr->recvBuffer);
-        svr->mainseqno = 2;
+    case SVR_RECV:
+        AGB_ASSERT(cmd->ptr == NULL);
+        MysteryGiftLink_InitRecv(&svr->link, cmd->parameter, svr->recvBuffer);
+        svr->funcId = FUNC_RECV;
         break;
-    case 3:
-        // jump
-        AGB_ASSERT(cmd->flag == FALSE);
+    case SVR_GOTO:
+        AGB_ASSERT(cmd->parameter == 0);
         svr->cmdidx = 0;
-        svr->cmdBuffer = cmd->parameter;
+        svr->script = cmd->ptr;
         break;
-    case 5:
-        // get_1442CC
-        AGB_ASSERT(cmd->flag == FALSE);
-        AGB_ASSERT(cmd->parameter == NULL);
-        memcpy(svr->mevent_unk1442cc, svr->recvBuffer, sizeof(struct MEventStruct_Unk1442CC));
+    case SVR_COPY_GAME_DATA:
+        AGB_ASSERT(cmd->parameter == 0);
+        AGB_ASSERT(cmd->ptr == NULL);
+        memcpy(svr->linkGameData, svr->recvBuffer, sizeof(*svr->linkGameData));
         break;
-    case 6:
-        // check_header__pass_false
-        AGB_ASSERT(cmd->flag == FALSE);
-        AGB_ASSERT(cmd->parameter == NULL);
-        svr->param = sub_801B6A0(svr->mevent_unk1442cc, FALSE);
+    case SVR_CHECK_GAME_DATA_CARD:
+        AGB_ASSERT(cmd->parameter == 0);
+        AGB_ASSERT(cmd->ptr == NULL);
+        svr->param = MysteryGift_ValidateLinkGameData(svr->linkGameData, FALSE);
         break;
-    case 30:
-        // check_header__pass_true
-        AGB_ASSERT(cmd->flag == FALSE);
-        AGB_ASSERT(cmd->parameter == NULL);
-        svr->param = sub_801B6A0(svr->mevent_unk1442cc, TRUE);
+    case SVR_CHECK_GAME_DATA_NEWS:
+        AGB_ASSERT(cmd->parameter == 0);
+        AGB_ASSERT(cmd->ptr == NULL);
+        svr->param = MysteryGift_ValidateLinkGameData(svr->linkGameData, TRUE);
         break;
-    case 4:
-        // jump_if_eq
-        if (svr->param == cmd->flag)
+    case SVR_GOTO_IF_EQ:
+        if (svr->param == cmd->parameter)
         {
             svr->cmdidx = 0;
-            svr->cmdBuffer = cmd->parameter;
+            svr->script = cmd->ptr;
         }
         break;
-    case 7:
-        // check_crc
-        AGB_ASSERT(cmd->flag == FALSE);
-        ptr = mevent_first_if_not_null_else_second(cmd->parameter, svr->wonder_card);
-        svr->param = sub_801B6EC(ptr, svr->mevent_unk1442cc, ptr);
+    case SVR_CHECK_EXISTING_CARD:
+        AGB_ASSERT(cmd->parameter == 0);
+        ptr = MysteryGiftServer_GetSendData(cmd->ptr, svr->card);
+        svr->param = MysteryGift_CompareCardFlags(ptr, svr->linkGameData, ptr);
         break;
-    case 8:
-        // read_word
-        AGB_ASSERT(cmd->flag == FALSE);
-        AGB_ASSERT(cmd->parameter == NULL);
+    case SVR_READ_RESPONSE:
+        AGB_ASSERT(cmd->parameter == 0);
+        AGB_ASSERT(cmd->ptr == NULL);
         svr->param = *(u32 *)svr->recvBuffer;
         break;
-    case 9:
-        AGB_ASSERT(cmd->flag == FALSE);
-        ptr = mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord);
-        svr->param = sub_801B708(ptr, svr->mevent_unk1442cc, ptr);
+    case SVR_CHECK_EXISTING_STAMPS:
+        AGB_ASSERT(cmd->parameter == 0);
+        ptr = MysteryGiftServer_GetSendData(cmd->ptr, &svr->stamp);
+        svr->param = MysteryGift_CheckStamps(ptr, svr->linkGameData, ptr);
         break;
-    case 10:
-        AGB_ASSERT(cmd->parameter == NULL);
-        svr->param = MEventStruct_Unk1442CC_GetValueNFrom_unk_20(svr->mevent_unk1442cc, cmd->flag);
+    case SVR_GET_CARD_STAT:
+        AGB_ASSERT(cmd->ptr == NULL);
+        svr->param = MysteryGift_GetCardStatFromLinkData(svr->linkGameData, cmd->parameter);
         break;
-    case 11:
-        AGB_ASSERT(cmd->flag == FALSE);
-        svr->param = MysteryGift_DoesQuestionnaireMatch(svr->mevent_unk1442cc, cmd->parameter);
+    case SVR_CHECK_QUESTIONNAIRE:
+        AGB_ASSERT(cmd->parameter == 0);
+        svr->param = MysteryGift_DoesQuestionnaireMatch(svr->linkGameData, cmd->ptr);
         break;
-    case 12:
-        AGB_ASSERT(cmd->flag == FALSE);
-        svr->param = mevent_compare_pointers(cmd->parameter, *(void **)svr->recvBuffer);
+    case SVR_COMPARE:
+        AGB_ASSERT(cmd->parameter == 0);
+        svr->param = MysteryGiftServer_Compare(cmd->ptr, *(void **)svr->recvBuffer);
         break;
-    case 14:
-        AGB_ASSERT(cmd->flag == FALSE);
-        mevent_srv_common_init_send(svr, 0x17, mevent_first_if_not_null_else_second(cmd->parameter, svr->wonder_news), sizeof(struct WonderNews));
+    case SVR_LOAD_NEWS:
+        AGB_ASSERT(cmd->parameter == 0);
+        MysteryGiftServer_InitSend(svr, MG_LINKID_NEWS, MysteryGiftServer_GetSendData(cmd->ptr, svr->news), sizeof(*svr->news));
         break;
-    case 13:
-        AGB_ASSERT(cmd->flag == FALSE);
-        mevent_srv_common_init_send(svr, 0x16, mevent_first_if_not_null_else_second(cmd->parameter, svr->wonder_card), sizeof(struct WonderCard));
+    case SVR_LOAD_CARD:
+        AGB_ASSERT(cmd->parameter == 0);
+        MysteryGiftServer_InitSend(svr, MG_LINKID_CARD, MysteryGiftServer_GetSendData(cmd->ptr, svr->card), sizeof(*svr->card));
         break;
-    case 16:
-        AGB_ASSERT(cmd->flag == FALSE);
-        mevent_srv_common_init_send(svr, 0x18, mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord), 4);
+    case SVR_LOAD_STAMP:
+        AGB_ASSERT(cmd->parameter == 0);
+        MysteryGiftServer_InitSend(svr, MG_LINKID_STAMP, MysteryGiftServer_GetSendData(cmd->ptr, &svr->stamp), sizeof(svr->stamp));
         break;
-    case 15:
-        if (cmd->parameter == NULL)
-            mevent_srv_common_init_send(svr, 0x19, svr->sendBuffer1, svr->sendBuffer1Size);
+    case SVR_LOAD_RAM_SCRIPT:
+        if (cmd->ptr == NULL)
+            MysteryGiftServer_InitSend(svr, MG_LINKID_RAM_SCRIPT, svr->ramScript, svr->ramScriptSize);
         else
-            mevent_srv_common_init_send(svr, 0x19, cmd->parameter, cmd->flag);
+            MysteryGiftServer_InitSend(svr, MG_LINKID_RAM_SCRIPT, cmd->ptr, cmd->parameter);
         break;
-    case 18:
-        if (cmd->parameter == NULL)
-            mevent_srv_common_init_send(svr, 0x10, svr->sendBuffer2, svr->sendBuffer2Size);
+    case SVR_LOAD_CLIENT_SCRIPT:
+        if (cmd->ptr == NULL)
+            MysteryGiftServer_InitSend(svr, MG_LINKID_CLIENT_SCRIPT, svr->clientScript, svr->clientScriptSize);
         else
-            mevent_srv_common_init_send(svr, 0x10, cmd->parameter, cmd->flag);
+            MysteryGiftServer_InitSend(svr, MG_LINKID_CLIENT_SCRIPT, cmd->ptr, cmd->parameter);
         break;
-    case 19:
-        AGB_ASSERT(cmd->flag == FALSE);
-        mevent_srv_common_init_send(svr, 0x1a, cmd->parameter, 188);
+    case SVR_LOAD_EREADER_TRAINER:
+        AGB_ASSERT(cmd->parameter == 0);
+        MysteryGiftServer_InitSend(svr, MG_LINKID_EREADER_TRAINER, cmd->ptr, sizeof(struct BattleTowerEReaderTrainer));
         break;
-    case 20:
-        mevent_srv_common_init_send(svr, 0x15, cmd->parameter, cmd->flag);
+    case SVR_LOAD_MSG:
+        MysteryGiftServer_InitSend(svr, MG_LINKID_DYNAMIC_MSG, cmd->ptr, cmd->parameter);
         break;
-    case 17:
-        mevent_srv_common_init_send(svr, 0x1c, cmd->parameter, cmd->flag);
+    case SVR_LOAD_UNK_2:
+        MysteryGiftServer_InitSend(svr, MG_LINKID_UNK_2, cmd->ptr, cmd->parameter);
         break;
-    case 22:
-        AGB_ASSERT(cmd->flag == FALSE);
-        memcpy(svr->wonder_card, cmd->parameter, 332);
+    case SVR_COPY_CARD:
+        AGB_ASSERT(cmd->parameter == 0);
+        memcpy(svr->card, cmd->ptr, sizeof(*svr->card));
         break;
-    case 23:
-        AGB_ASSERT(cmd->flag == FALSE);
-        memcpy(svr->wonder_news, cmd->parameter, 444);
+    case SVR_COPY_NEWS:
+        AGB_ASSERT(cmd->parameter == 0);
+        memcpy(svr->news, cmd->ptr, sizeof(*svr->news));
         break;
-    case 21:
-        AGB_ASSERT(cmd->flag == FALSE);
-        svr->sendWord = *(u32 *)cmd->parameter;
+    case SVR_COPY_STAMP:
+        AGB_ASSERT(cmd->parameter == 0);
+        svr->stamp = *(u32 *)cmd->ptr;
         break;
-    case 24:
-        svr->sendBuffer1 = cmd->parameter;
-        svr->sendBuffer1Size = cmd->flag;
+    case SVR_SET_RAM_SCRIPT:
+        svr->ramScript = cmd->ptr;
+        svr->ramScriptSize = cmd->parameter;
         break;
-    case 25:
-        svr->sendBuffer2 = cmd->parameter;
-        svr->sendBuffer2Size = cmd->flag;
+    case SVR_SET_CLIENT_SCRIPT:
+        svr->clientScript = cmd->ptr;
+        svr->clientScriptSize = cmd->parameter;
         break;
-    case 26:
-        AGB_ASSERT(cmd->flag == FALSE && cmd->parameter == NULL);
-        memcpy(svr->wonder_card, GetSavedWonderCard(), 332);
-        WonderCard_ResetInternalReceivedFlag(svr->wonder_card);
+    case SVR_COPY_SAVED_CARD:
+        AGB_ASSERT(cmd->parameter == 0 && cmd->ptr == NULL);
+        memcpy(svr->card, GetSavedWonderCard(), sizeof(*svr->card));
+        DisableWonderCardSending(svr->card);
         break;
-    case 27:
-        AGB_ASSERT(cmd->flag == FALSE && cmd->parameter == NULL);
-        memcpy(svr->wonder_news, GetSavedWonderNews(), 444);
+    case SVR_COPY_SAVED_NEWS:
+        AGB_ASSERT(cmd->parameter == 0 && cmd->ptr == NULL);
+        memcpy(svr->news, GetSavedWonderNews(), sizeof(*svr->news));
         break;
-    case 28:
-        AGB_ASSERT(cmd->flag == FALSE && cmd->parameter == NULL);
-        svr->sendBuffer1 = GetSavedRamScriptIfValid();
+    case SVR_COPY_SAVED_RAM_SCRIPT:
+        AGB_ASSERT(cmd->parameter == 0 && cmd->ptr == NULL);
+        svr->ramScript = GetSavedRamScriptIfValid();
         break;
-    case 29:
-        mevent_srv_common_init_send(svr, 0x1b, cmd->parameter, cmd->flag);
+    case SVR_LOAD_UNK_1:
+        MysteryGiftServer_InitSend(svr, MG_LINKID_UNK_1, cmd->ptr, cmd->parameter);
         break;
     }
 
-    return 1;
+    return SVR_RET_ACTIVE;
 }
 
-static u32 (*const func_tbl[])(struct mevent_srv_common *) = {
-    common_mainseq_0,
-    common_mainseq_1,
-    common_mainseq_2,
-    common_mainseq_3,
-    common_mainseq_4
+static u32 (*const sFuncTable[])(struct MysteryGiftServer *) = {
+    [FUNC_INIT] = Server_Init,
+    [FUNC_DONE] = Server_Done,
+    [FUNC_RECV] = Server_Recv,
+    [FUNC_SEND] = Server_Send,
+    [FUNC_RUN] = Server_Run
 };
 
-static u32 mevent_srv_exec_common(struct mevent_srv_common * svr)
+static u32 MysteryGiftServer_CallFunc(struct MysteryGiftServer * svr)
 {
     u32 response;
-    AGB_ASSERT(svr->mainseqno < ARRAY_COUNT(func_tbl));
-    response = func_tbl[svr->mainseqno](svr);
-    AGB_ASSERT(svr->mainseqno < ARRAY_COUNT(func_tbl));
+    AGB_ASSERT(svr->funcId < ARRAY_COUNT(sFuncTable));
+    response = sFuncTable[svr->funcId](svr);
+    AGB_ASSERT(svr->funcId < ARRAY_COUNT(sFuncTable));
     return response;
 }