diff --git a/common_syms/ereader_screen.txt b/common_syms/ereader_screen.txt new file mode 100644 index 000000000..2189eedbc --- /dev/null +++ b/common_syms/ereader_screen.txt @@ -0,0 +1 @@ +gEReaderData diff --git a/common_syms/mevent.txt b/common_syms/mevent.txt deleted file mode 100644 index af4db66e6..000000000 --- a/common_syms/mevent.txt +++ /dev/null @@ -1 +0,0 @@ -sMEventSendToEReaderManager diff --git a/data/event_scripts.s b/data/event_scripts.s index 5e349996d..d6aa4d512 100644 --- a/data/event_scripts.s +++ b/data/event_scripts.s @@ -36,6 +36,7 @@ #include "constants/easy_chat.h" #include "constants/trainer_card.h" #include "constants/help_system.h" +#include "constants/mystery_gift.h" .include "asm/macros.inc" .include "asm/macros/event.inc" .set FALSE, 0 diff --git a/data/maps/CeruleanCity_House4/scripts.inc b/data/maps/CeruleanCity_House4/scripts.inc index e812d3b73..42ddde3f2 100644 --- a/data/maps/CeruleanCity_House4/scripts.inc +++ b/data/maps/CeruleanCity_House4/scripts.inc @@ -1,5 +1,8 @@ .set LOCALID_WONDER_NEWS_BERRY_MAN, 1 +.set REWARD_TYPE, VAR_0x8004 +.set REWARD_ITEM, VAR_0x8008 + CeruleanCity_House4_MapScripts:: .byte 0 @@ -7,62 +10,69 @@ CeruleanCity_House4_EventScript_WonderNewsBerryMan:: goto_if_questlog EventScript_ReleaseEnd special QuestLog_CutRecording lock - specialvar VAR_0x8004, GetMENewsJisanItemAndState - copyvar VAR_0x8008, VAR_RESULT - goto_if_eq VAR_0x8004, 0, CeruleanCity_House4_EventScript_NoNews - goto_if_eq VAR_0x8004, 1, CeruleanCity_House4_EventScript_News1 - goto_if_eq VAR_0x8004, 2, CeruleanCity_House4_EventScript_News2 - goto_if_eq VAR_0x8004, 3, CeruleanCity_House4_EventScript_NewsNotSpread - goto_if_eq VAR_0x8004, 4, CeruleanCity_House4_EventScript_NewsSpread1 - goto_if_eq VAR_0x8004, 5, CeruleanCity_House4_EventScript_NewsSpread2 - goto_if_eq VAR_0x8004, 6, CeruleanCity_House4_EventScript_NewsDone + specialvar REWARD_TYPE, WonderNews_GetRewardInfo + copyvar REWARD_ITEM, VAR_RESULT + goto_if_eq REWARD_TYPE, NEWS_REWARD_NONE, CeruleanCity_House4_EventScript_NoNews + goto_if_eq REWARD_TYPE, NEWS_REWARD_RECV_SMALL, CeruleanCity_House4_EventScript_Reward_RecvSmall + goto_if_eq REWARD_TYPE, NEWS_REWARD_RECV_BIG, CeruleanCity_House4_EventScript_Reward_RecvBig + goto_if_eq REWARD_TYPE, NEWS_REWARD_WAITING, CeruleanCity_House4_EventScript_Waiting + goto_if_eq REWARD_TYPE, NEWS_REWARD_SENT_SMALL, CeruleanCity_House4_EventScript_Reward_SentSmall + goto_if_eq REWARD_TYPE, NEWS_REWARD_SENT_BIG, CeruleanCity_House4_EventScript_Reward_SentBig + goto_if_eq REWARD_TYPE, NEWS_REWARD_AT_MAX, CeruleanCity_House4_EventScript_AtMax end +@ Mystery Gift is not enabled, or the player has no saved Wonder News CeruleanCity_House4_EventScript_NoNews:: msgbox CeruleanCity_House4_Text_NothingEntertaining release end -CeruleanCity_House4_EventScript_News1:: +@ Small reward for receiving Wonder News from friend +CeruleanCity_House4_EventScript_Reward_RecvSmall:: call CeruleanCity_House4_EventScript_MovementReactionToNews msgbox CeruleanCity_House4_Text_NewNewsInformativeHaveThis - giveitem VAR_0x8008 + giveitem REWARD_ITEM goto_if_eq VAR_RESULT, FALSE, CeruleanCity_House4_EventScript_NoRoomForBerries release end -CeruleanCity_House4_EventScript_News2:: +@ Big reward for receiving Wonder News from non-friend source +CeruleanCity_House4_EventScript_Reward_RecvBig:: call CeruleanCity_House4_EventScript_MovementReactionToNews msgbox CeruleanCity_House4_Text_IncredibleNewsHaveBerries - giveitem VAR_0x8008, 4 + giveitem REWARD_ITEM, 4 goto_if_eq VAR_RESULT, FALSE, CeruleanCity_House4_EventScript_NoRoomForBerries release end -CeruleanCity_House4_EventScript_NewsNotSpread:: +@ Player has not recently sent Wonder News +CeruleanCity_House4_EventScript_Waiting:: applymovement LOCALID_WONDER_NEWS_BERRY_MAN, Common_Movement_FacePlayer waitmovement 0 msgbox CeruleanCity_House4_Text_WishCouldShareNewsWithOthers release end -CeruleanCity_House4_EventScript_NewsSpread1:: +@ Small reward for sending Wonder News every 1-3 times +CeruleanCity_House4_EventScript_Reward_SentSmall:: call CeruleanCity_House4_EventScript_MovementReactionToNews msgbox CeruleanCity_House4_Text_ThanksForSpreadingNewsTakeThis - giveitem VAR_0x8008 + giveitem REWARD_ITEM goto_if_eq VAR_RESULT, FALSE, CeruleanCity_House4_EventScript_NoRoomForBerries release end -CeruleanCity_House4_EventScript_NewsSpread2:: +@ Big reward for sending Wonder News every 4th time +CeruleanCity_House4_EventScript_Reward_SentBig:: call CeruleanCity_House4_EventScript_MovementReactionToNews msgbox CeruleanCity_House4_Text_MagnificentNewsSpreadHaveBerries - giveitem VAR_0x8008, 4 + giveitem REWARD_ITEM, 4 goto_if_eq VAR_RESULT, FALSE, CeruleanCity_House4_EventScript_NoRoomForBerries release end -CeruleanCity_House4_EventScript_NewsDone:: +@ Player has hit reward limit and must wait to receive new rewards +CeruleanCity_House4_EventScript_AtMax:: applymovement LOCALID_WONDER_NEWS_BERRY_MAN, Common_Movement_FacePlayer waitmovement 0 msgbox CeruleanCity_House4_Text_EnjoyingMyselfWithAllSortsOfNews diff --git a/data/mystery_event_msg.s b/data/mystery_event_msg.s index 26048ca52..d4fe7faf2 100644 --- a/data/mystery_event_msg.s +++ b/data/mystery_event_msg.s @@ -17,9 +17,9 @@ MysteryEventScript_StampCard:: setvaddress MysteryEventScript_StampCard setorcopyvar VAR_RESULT, 1 - specialvar VAR_0x8008, BattleCardAction + specialvar VAR_0x8008, GetMysteryGiftCardStat setorcopyvar VAR_RESULT, 0 - specialvar VAR_0x8009, BattleCardAction + specialvar VAR_0x8009, GetMysteryGiftCardStat subvar VAR_0x8008, VAR_0x8009 buffernumberstring STR_VAR_1, VAR_0x8008 lock @@ -162,7 +162,7 @@ MysteryEventScript_BattleCard:: setvaddress MysteryEventScript_BattleCard vgoto_if_set FLAG_MYSTERY_GIFT_DONE, MysteryEventScript_BattleCardInfo setorcopyvar VAR_RESULT, 2 - specialvar VAR_0x8008, BattleCardAction + specialvar VAR_0x8008, GetMysteryGiftCardStat vgoto_if_ne VAR_0x8008, 3, MysteryEventScript_BattleCardInfo lock faceplayer @@ -208,7 +208,7 @@ MysteryEventScript_AuroraTicket:: setvaddress MysteryEventScript_AuroraTicket lock faceplayer - vgoto_if_set FLAG_GOT_AURORA_TICKET, AuroraTicket_Obtained + vgoto_if_set FLAG_RECEIVED_AURORA_TICKET, AuroraTicket_Obtained vgoto_if_set FLAG_FOUGHT_DEOXYS, AuroraTicket_Obtained checkitem ITEM_AURORA_TICKET, 1 vgoto_if_eq VAR_RESULT, TRUE, AuroraTicket_Obtained @@ -219,7 +219,7 @@ MysteryEventScript_AuroraTicket:: vgoto_if_eq VAR_RESULT, FALSE, AuroraTicket_NoBagSpace giveitem ITEM_AURORA_TICKET setflag FLAG_ENABLE_SHIP_BIRTH_ISLAND - setflag FLAG_GOT_AURORA_TICKET + setflag FLAG_RECEIVED_AURORA_TICKET vmessage sText_AuroraTicket2 waitmessage waitbuttonpress @@ -266,7 +266,7 @@ MysteryEventScript_MysticTicket:: setvaddress MysteryEventScript_MysticTicket lock faceplayer - vgoto_if_set FLAG_GOT_MYSTIC_TICKET, MysticTicket_Obtained + vgoto_if_set FLAG_RECEIVED_MYSTIC_TICKET, MysticTicket_Obtained vgoto_if_set FLAG_FOUGHT_LUGIA, MysticTicket_Obtained vgoto_if_set FLAG_FOUGHT_HO_OH, MysticTicket_Obtained checkitem ITEM_MYSTIC_TICKET, 1 @@ -278,7 +278,7 @@ MysteryEventScript_MysticTicket:: vgoto_if_eq VAR_RESULT, FALSE, MysticTicket_NoBagSpace giveitem ITEM_MYSTIC_TICKET setflag FLAG_ENABLE_SHIP_NAVEL_ROCK - setflag FLAG_GOT_MYSTIC_TICKET + setflag FLAG_RECEIVED_MYSTIC_TICKET vmessage sText_MysticTicket1 waitmessage waitbuttonpress diff --git a/data/scripts/cable_club.inc b/data/scripts/cable_club.inc index f725dbaea..e7f53ada2 100644 --- a/data/scripts/cable_club.inc +++ b/data/scripts/cable_club.inc @@ -3,7 +3,7 @@ CableClub_OnTransition:: end CableClub_EventScript_HideOrShowMysteryGiftMan:: - specialvar VAR_RESULT, ValidateReceivedWonderCard + specialvar VAR_RESULT, ValidateSavedWonderCard goto_if_eq VAR_RESULT, FALSE, EventScript_HideMysteryGiftMan clearflag FLAG_HIDE_MG_DELIVERYMEN return diff --git a/data/specials.inc b/data/specials.inc index f815d05d6..be6e3d575 100644 --- a/data/specials.inc +++ b/data/specials.inc @@ -392,16 +392,16 @@ gSpecials:: def_special Script_SetHelpContext def_special BackupHelpContext def_special RestoreHelpContext - def_special ValidateReceivedWonderCard + def_special ValidateSavedWonderCard def_special SetUnlockedPokedexFlags def_special InitUnionRoom def_special BufferUnionRoomPlayerName def_special QuestLog_StartRecordingInputsAfterDeferredEvent def_special GetMartClerkObjectId - def_special BattleCardAction + def_special GetMysteryGiftCardStat def_special GetQuestLogState def_special QuestLog_CutRecording - def_special GetMENewsJisanItemAndState + def_special WonderNews_GetRewardInfo def_special GetPCBoxToSendMon def_special OpenMuseumFossilPic def_special CloseMuseumFossilPic diff --git a/graphics/interface/unk_textbox_border.png b/graphics/interface/mystery_gift_textbox_border.png similarity index 100% rename from graphics/interface/unk_textbox_border.png rename to graphics/interface/mystery_gift_textbox_border.png diff --git a/include/constants/flags.h b/include/constants/flags.h index 5baa6c75c..24e44dd9e 100644 --- a/include/constants/flags.h +++ b/include/constants/flags.h @@ -701,26 +701,28 @@ #define FLAG_0x2A4 0x2A4 #define FLAG_CAN_USE_ROCKET_HIDEOUT_LIFT 0x2A5 #define FLAG_GOT_TEA 0x2A6 -#define FLAG_GOT_AURORA_TICKET 0x2A7 -#define FLAG_GOT_MYSTIC_TICKET 0x2A8 -#define FLAG_0x2A9 0x2A9 -#define FLAG_0x2AA 0x2AA -#define FLAG_0x2AB 0x2AB -#define FLAG_0x2AC 0x2AC -#define FLAG_0x2AD 0x2AD -#define FLAG_0x2AE 0x2AE -#define FLAG_0x2AF 0x2AF -#define FLAG_0x2B0 0x2B0 -#define FLAG_0x2B1 0x2B1 -#define FLAG_0x2B2 0x2B2 -#define FLAG_0x2B3 0x2B3 -#define FLAG_0x2B4 0x2B4 -#define FLAG_0x2B5 0x2B5 -#define FLAG_0x2B6 0x2B6 -#define FLAG_0x2B7 0x2B7 -#define FLAG_0x2B8 0x2B8 -#define FLAG_0x2B9 0x2B9 -#define FLAG_0x2BA 0x2BA +#define FLAG_RECEIVED_AURORA_TICKET 0x2A7 +#define FLAG_RECEIVED_MYSTIC_TICKET 0x2A8 +#define FLAG_RECEIVED_OLD_SEA_MAP 0x2A9 +#define FLAG_WONDER_CARD_UNUSED_1 0x2AA +#define FLAG_WONDER_CARD_UNUSED_2 0x2AB +#define FLAG_WONDER_CARD_UNUSED_3 0x2AC +#define FLAG_WONDER_CARD_UNUSED_4 0x2AD +#define FLAG_WONDER_CARD_UNUSED_5 0x2AE +#define FLAG_WONDER_CARD_UNUSED_6 0x2AF +#define FLAG_WONDER_CARD_UNUSED_7 0x2B0 +#define FLAG_WONDER_CARD_UNUSED_8 0x2B1 +#define FLAG_WONDER_CARD_UNUSED_9 0x2B2 +#define FLAG_WONDER_CARD_UNUSED_10 0x2B3 +#define FLAG_WONDER_CARD_UNUSED_11 0x2B4 +#define FLAG_WONDER_CARD_UNUSED_12 0x2B5 +#define FLAG_WONDER_CARD_UNUSED_13 0x2B6 +#define FLAG_WONDER_CARD_UNUSED_14 0x2B7 +#define FLAG_WONDER_CARD_UNUSED_15 0x2B8 +#define FLAG_WONDER_CARD_UNUSED_16 0x2B9 +#define FLAG_WONDER_CARD_UNUSED_17 0x2BA +#define NUM_WONDER_CARD_FLAGS (1 + FLAG_WONDER_CARD_UNUSED_17 - FLAG_RECEIVED_AURORA_TICKET) + #define FLAG_GOT_POWDER_JAR 0x2BB #define FLAG_FOUGHT_MEWTWO 0x2BC #define FLAG_FOUGHT_MOLTRES 0x2BD diff --git a/include/constants/mystery_gift.h b/include/constants/mystery_gift.h index 8ff71c3aa..13eb7f103 100644 --- a/include/constants/mystery_gift.h +++ b/include/constants/mystery_gift.h @@ -44,4 +44,12 @@ #define WONDER_CARD_FLAG_OFFSET 1000 +#define NEWS_REWARD_NONE 0 +#define NEWS_REWARD_RECV_SMALL 1 +#define NEWS_REWARD_RECV_BIG 2 +#define NEWS_REWARD_WAITING 3 +#define NEWS_REWARD_SENT_SMALL 4 +#define NEWS_REWARD_SENT_BIG 5 +#define NEWS_REWARD_AT_MAX 6 + #endif //GUARD_CONSTANTS_MYSTERY_GIFT_H diff --git a/include/constants/vars.h b/include/constants/vars.h index 56dafee12..5c7bbf8a3 100644 --- a/include/constants/vars.h +++ b/include/constants/vars.h @@ -84,7 +84,7 @@ // Bits 12-15 are the same for the player's party. // Used by Quest Log. #define VAR_QUEST_LOG_MON_COUNTS 0x4027 -#define VAR_MENEWS_JISAN_STEP_COUNTER 0x4028 +#define VAR_WONDER_NEWS_STEP_COUNTER 0x4028 #define VAR_0x4029 0x4029 #define VAR_0x402A 0x402A #define VAR_0x402B 0x402B diff --git a/include/easy_chat.h b/include/easy_chat.h index 853060f4f..ec5488bca 100644 --- a/include/easy_chat.h +++ b/include/easy_chat.h @@ -36,7 +36,7 @@ struct EasyChatWordsByLetter u8 *CopyEasyChatWord(u8 *dest, u16 word); u8 *ConvertEasyChatWordsToString(u8 *dest, const u16 *src, u16 columns, u16 rows); bool8 EC_DoesEasyChatStringFitOnLine(const u16 *easyChatWords, u8 columns, u8 rows, u16 maxLength); -void EC_ResetMEventProfileMaybe(void); +void InitQuestionnaireWords(void); void InitEasyChatPhrases(void); void EnableRareWord(u8); bool8 InitEasyChatSelection(void); diff --git a/include/ereader_helpers.h b/include/ereader_helpers.h index d6f3d13bb..244d6e2ef 100644 --- a/include/ereader_helpers.h +++ b/include/ereader_helpers.h @@ -14,17 +14,20 @@ enum { #define EREADER_XFER_EXE 1 #define EREADER_XFER_CHK 2 #define EREADER_XFER_SHIFT 0 -#define EREADER_XFER_MASK 3 +#define EREADER_XFER_MASK ((EREADER_XFER_EXE | EREADER_XFER_CHK) << EREADER_XFER_SHIFT) #define EREADER_CANCEL_TIMEOUT 1 #define EREADER_CANCEL_KEY 2 -#define EREADER_CANCEL_MASK 0xC #define EREADER_CANCEL_SHIFT 2 +#define EREADER_CANCEL_TIMEOUT_MASK (EREADER_CANCEL_TIMEOUT << EREADER_CANCEL_SHIFT) +#define EREADER_CANCEL_KEY_MASK (EREADER_CANCEL_KEY << EREADER_CANCEL_SHIFT) +#define EREADER_CANCEL_MASK ((EREADER_CANCEL_TIMEOUT | EREADER_CANCEL_KEY) << EREADER_CANCEL_SHIFT) #define EREADER_CHECKSUM_OK 1 #define EREADER_CHECKSUM_ERR 2 -#define EREADER_CHECKSUM_MASK 0x30 #define EREADER_CHECKSUM_SHIFT 4 +#define EREADER_CHECKSUM_OK_MASK (EREADER_CHECKSUM_OK << EREADER_CHECKSUM_SHIFT) +#define EREADER_CHECKSUM_MASK ((EREADER_CHECKSUM_OK | EREADER_CHECKSUM_ERR) << EREADER_CHECKSUM_SHIFT) void EReaderHelper_SerialCallback(void); void EReaderHelper_Timer3Callback(void); diff --git a/include/event_data.h b/include/event_data.h index 5a6f98c6c..285b4cc83 100644 --- a/include/event_data.h +++ b/include/event_data.h @@ -49,8 +49,8 @@ bool8 FlagGet(u16 id); u16 * GetVarPointer(u16 id); bool32 IsMysteryGiftEnabled(void); void ResetSpecialVars(void); -void ResetMysteryEventFlags(void); -void ResetMysteryEventVars(void); +void ClearMysteryGiftFlags(void); +void ClearMysteryGiftVars(void); bool32 IsNationalPokedexEnabled(void); void EnableNationalPokedex_RSE(void); void ClearTempFieldEventData(void); diff --git a/include/global.h b/include/global.h index 79dedcdc2..3c643f184 100644 --- a/include/global.h +++ b/include/global.h @@ -627,15 +627,15 @@ struct FameCheckerSaveData struct WonderNewsMetadata { - u8 unk_0_0:2; - u8 unk_0_2:3; - u8 unk_0_5:3; + u8 newsType:2; + u8 sentRewardCounter:3; + u8 rewardCounter:3; u8 berry; }; struct WonderNews { - u16 newsId; + u16 id; u8 sendType; // SEND_TYPE_* u8 bgType; u8 titleText[WONDER_NEWS_TEXT_LENGTH]; diff --git a/include/link.h b/include/link.h index 6de96da5e..7e5e5ecb0 100644 --- a/include/link.h +++ b/include/link.h @@ -85,12 +85,12 @@ #define LINKCMD_PARTNER_CANCEL_TRADE 0xEECC #define LINKCMD_NONE 0xEFFF -#define LINKTYPE_TRADE 0x1111 // trade -#define LINKTYPE_0x1122 0x1122 // trade +#define LINKTYPE_TRADE 0x1111 +#define LINKTYPE_TRADE_CONNECTING 0x1122 #define LINKTYPE_TRADE_SETUP 0x1133 -#define LINKTYPE_0x1144 0x1144 // trade +#define LINKTYPE_TRADE_DISCONNECTED 0x1144 #define LINKTYPE_BATTLE 0x2211 -#define LINKTYPE_0x2222 0x2222 // unused battle? +#define LINKTYPE_UNUSED_BATTLE 0x2222 // Unused, inferred from gap #define LINKTYPE_SINGLE_BATTLE 0x2233 #define LINKTYPE_DOUBLE_BATTLE 0x2244 #define LINKTYPE_MULTI_BATTLE 0x2255 @@ -100,7 +100,12 @@ #define LINKTYPE_RECORD_MIX_BEFORE 0x3311 #define LINKTYPE_RECORD_MIX_AFTER 0x3322 #define LINKTYPE_BERRY_BLENDER_SETUP 0x4411 +#define LINKTYPE_BERRY_BLENDER 0x4422 +#define LINKTYPE_MYSTERY_EVENT 0x5501 +#define LINKTYPE_EREADER_FRLG 0x5502 +#define LINKTYPE_EREADER_EM 0x5503 #define LINKTYPE_CONTEST_GMODE 0x6601 +#define LINKTYPE_CONTEST_EMODE 0x6602 enum { BLOCK_REQ_SIZE_NONE, // Identical to 200 @@ -110,8 +115,9 @@ enum { BLOCK_REQ_SIZE_40, }; -#define MASTER_HANDSHAKE 0x8FFF -#define SLAVE_HANDSHAKE 0xB9A0 +#define MASTER_HANDSHAKE 0x8FFF +#define SLAVE_HANDSHAKE 0xB9A0 +#define EREADER_HANDSHAKE 0xCCD0 #define IsSendCmdComplete() (gSendCmd[0] == 0) diff --git a/include/link_rfu.h b/include/link_rfu.h index e3b60ccb4..dbc14ea03 100644 --- a/include/link_rfu.h +++ b/include/link_rfu.h @@ -233,8 +233,6 @@ extern struct RfuGameData gHostRfuGameData; extern u8 gHostRfuUsername[]; extern struct RfuManager gRfu; -void AddTextPrinterToWindow1(const u8 *str); -bool32 PrintMysteryGiftMenuMessage(u8 * cmdPtr, const u8 * src); void LinkRfu_FatalError(void); void MG_DrawCheckerboardPattern(void); void Rfu_SetCloseLinkCallback(void); @@ -324,7 +322,7 @@ void RfuSetNormalDisconnectMode(void); void SetUnionRoomChatPlayerData(u32 numPlayers); void ClearRecvCommands(void); -#include "mevent_server.h" -extern const struct mevent_server_cmd gServerScript_ClientCanceledCard[]; +#include "mystery_gift_server.h" +extern const struct MysteryGiftServerCmd gServerScript_ClientCanceledCard[]; #endif //GUARD_LINK_RFU_H diff --git a/include/main.h b/include/main.h index a27145c7b..4a5f79a9d 100644 --- a/include/main.h +++ b/include/main.h @@ -69,7 +69,8 @@ void StartTimer1(void); void SeedRngAndSetTrainerId(void); u16 GetGeneratedTrainerIdLower(void); -extern const char RomHeaderGameCode[4]; +#define GAME_CODE_LENGTH 4 +extern const char RomHeaderGameCode[GAME_CODE_LENGTH]; extern const char RomHeaderSoftwareVersion; extern u8 gLinkTransferringData; diff --git a/include/menews_jisan.h b/include/menews_jisan.h deleted file mode 100644 index 8e1c251f9..000000000 --- a/include/menews_jisan.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef GUARD_MENEWS_JISAN_H -#define GUARD_MENEWS_JISAN_H - -#include "global.h" - -void MENewsJisan_SetRandomReward(u32 a0); -void MENewsJisanReset(void); -void MENewsJisanStepCounter(void); - -#endif //GUARD_MENEWS_JISAN_H diff --git a/include/mevent.h b/include/mevent.h deleted file mode 100644 index 92c664d46..000000000 --- a/include/mevent.h +++ /dev/null @@ -1,108 +0,0 @@ -#ifndef GUARD_MEVENT_H -#define GUARD_MEVENT_H - -#include "global.h" - -#define CARD_STAT_BATTLES_WON 0 -#define CARD_STAT_BATTLES_LOST 1 -#define CARD_STAT_NUM_TRADES 2 -#define CARD_STAT_NUM_STAMPS 3 -#define CARD_STAT_MAX_STAMPS 4 - -enum { - NEWS_INPUT_A, - NEWS_INPUT_B, - NEWS_INPUT_SCROLL_UP, - NEWS_INPUT_SCROLL_DOWN, - NEWS_INPUT_NONE = 0xFF -}; - -struct MEventClientHeaderStruct -{ - u32 unk_00; - u16 unk_04; - u32 unk_08; - u16 unk_0C; - u32 unk_10; - u16 id; - u16 unk_16[4]; - struct WonderCardMetadata unk_20; - u8 maxDistributionMons; - u8 playerName[7]; - u8 playerTrainerId[4]; - u16 easyChatProfile[6]; - u8 gameCode[4]; - u8 version; -}; - -struct MEvent_Str_1 -{ - u16 status; - size_t size; - const void *data; -}; - -struct MEvent_Str_2 -{ - u8 fill_00[0x40]; -}; - -struct WonderGraphics -{ - u8 titleTextPal:4; - u8 bodyTextPal:4; - u8 footerTextPal:4; - u8 stampShadowPal:4; - const u8 * tiles; - const u8 * map; - const u16 * pal; -}; - -extern const u16 gCard1Pal[]; -extern const u16 gCard2Pal[]; -extern const u16 gCard3Pal[]; -extern const u16 gCard4Pal[]; -extern const u16 gCard5Pal[]; - -struct WonderNews * GetSavedWonderNews(void); -struct WonderCard * GetSavedWonderCard(void); -struct WonderCardMetadata * sav1_get_mevent_buffer_2(void); -struct WonderNewsMetadata * GetMENewsJisanStructPtr(void); -bool32 OverwriteSavedWonderNewsWithReceivedNews(const struct WonderNews * src); -bool32 ValidateReceivedWonderNews(void); -bool32 ValidateReceivedWonderCard(void); -bool32 MEvent_HaveAlreadyReceivedWonderNews(const u8 * src); -bool32 OverwriteSavedWonderCardWithReceivedCard(const struct WonderCard * data); -void MEvent_WonderCardResetUnk08_6(struct WonderCard * buffer); -bool32 MEvent_ReceiveDistributionMon(const u16 * data); -void BuildMEventClientHeader(struct MEventClientHeaderStruct * data); -bool32 ValidateMEventClientHeader(const struct MEventClientHeaderStruct * data); -u32 sub_8144418(const u16 * a0, const struct MEventClientHeaderStruct * a1, void *unused); -u32 MEvent_CanPlayerReceiveDistributionMon(const u16 * a0, const struct MEventClientHeaderStruct * a1, void *unused); -bool32 sub_8144474(const struct MEventClientHeaderStruct * a0, const u16 * a1); -u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command); -bool32 WonderCard_Init(struct WonderCard * card, struct WonderCardMetadata * metadata); -bool32 WonderNews_Init(const struct WonderNews * news); -s32 WonderCard_Enter(void); -s32 WonderNews_Enter(void); -void DestroyWonderCard(void); -void DestroyWonderNews(void); -void WonderCard_Destroy(void); -void WonderNews_Destroy(void); -s32 WonderCard_Exit(bool32 flag); -s32 WonderNews_Exit(bool32 flag); -bool32 CheckReceivedGiftFromWonderCard(void); -void WonderNews_AddScrollIndicatorArrowPair(void); -void WonderNews_RemoveScrollIndicatorArrowPair(void); -bool32 WonderNews_Test_Unk_02(void); -bool32 WonderCard_Test_Unk_08_6(void); -u32 WonderNews_GetInput(u16 input); -void InitMEventData(void); -u16 MEvent_GetBattleCardCount(u32 command); -void MysteryGift_TryIncrementStat(u32 eventId, u32 trainerId); -u16 *GetMEventProfileECWordsMaybe(void); -void MysteryGift_DisableStats(void); -bool32 MysteryGift_TryEnableStatsByFlagId(u16 flagId); -u16 GetWonderCardFlagId(void); - -#endif //GUARD_MEVENT_H diff --git a/include/mevent_server.h b/include/mevent_server.h deleted file mode 100644 index 9560fe25f..000000000 --- a/include/mevent_server.h +++ /dev/null @@ -1,129 +0,0 @@ -#ifndef GUARD_MEVENT_SERVER_H -#define GUARD_MEVENT_SERVER_H - -#include "global.h" - -#define ME_SEND_BUF_SIZE 0x400 - -struct mevent_srv_sub -{ - s32 seqno; - u8 sendPlayerNo; - u8 recvPlayerNo; - u16 recvIdent; - u16 recvCounter; - u16 recvCRC; - u16 recvSize; - u16 sendIdent; - u16 sendCounter; - u16 sendCRC; - u16 sendSize; - void *recvBfr; - const void *sendBfr; - u32 (*recvFunc)(struct mevent_srv_sub *); - u32 (*sendFunc)(struct mevent_srv_sub *); -}; - -struct send_recv_header -{ - u16 ident; - u16 crc; - u16 size; -}; - -struct mevent_client_cmd -{ - u32 instr; - u32 parameter; -}; - -// Client commands -#define CLI_RETURN(x) {.instr = 1, .parameter = x} -#define CLI_RECEIVE(x) {.instr = 2, .parameter = x} -#define CLI_WAITSND {.instr = 3, .parameter = 0} -#define CLI_JUMPBUF {.instr = 4, .parameter = 0} -#define CLI_SNDHEAD {.instr = 8, .parameter = 0} -#define CLI_VLDNEWS {.instr = 9, .parameter = 0} -#define CLI_RECVSAV {.instr = 10, .parameter = 0} -#define CLI_RECVBUF {.instr = 12, .parameter = 0} -#define CLI_REQWORD {.instr = 13, .parameter = 0} -#define CLI_SNDWORD {.instr = 14, .parameter = 0} -#define CLI_RECVMON {.instr = 16, .parameter = 0} -#define CLI_RECVRAM {.instr = 17, .parameter = 0} -#define CLI_SENDALL {.instr = 20, .parameter = 0} - -struct mevent_client -{ - u32 unk_00; - u32 param; - u32 mainseqno; - u32 flag; - u32 cmdidx; - void *sendBuffer; - void *recvBuffer; - struct mevent_client_cmd * cmdBuffer; - void *buffer; - struct mevent_srv_sub manager; -}; - -struct mevent_server_cmd -{ - u32 instr; - bool32 flag; - void *parameter; -}; - -// Server commands -#define SRV_RETURN(x) {.instr = 0, .flag = x} -#define SRV_WAITSND {.instr = 1} -#define SRV_RECV(x) {.instr = 2, .flag = x} -#define SRV_BRANCH(y) {.instr = 3, .parameter = (void *)y} -#define SRV_BRANCHIF(x, y) {.instr = 4, .flag = x, .parameter = (void *)y} -#define SRV_READ_1442CC {.instr = 5} -#define SRV_VALID_1442CC {.instr = 6} -#define SRV_CHECK_1442CC_14 {.instr = 7} -#define SRV_READWORD {.instr = 8} -#define SRV_SEND_CARD {.instr = 13} -#define SRV_SEND_NEWS {.instr = 14} -#define SRV_BUFFER_SEND {.instr = 15} -#define SRV_SEND(x, y) {.instr = 18, .flag = x, .parameter = (void *)y} -#define SRV_SENDSTR(x, y) {.instr = 20, .flag = x, .parameter = (void *)y} -#define SRV_BUFFER_CARD {.instr = 26} -#define SRV_BUFFER_NEWS {.instr = 27} -#define SRV_RAM_SCRIPT_IF_VALID {.instr = 28} - -struct mevent_srv_common -{ - u32 unk_00; - u32 param; - u32 mainseqno; - u32 cmdidx; - const struct mevent_server_cmd * cmdBuffer; - void *recvBuffer; - struct WonderCard * card; - struct WonderNews * news; - struct MEventClientHeaderStruct * mevent_unk1442cc; - void *sendBuffer1; - u32 sendBuffer1Size; - void *sendBuffer2; - u32 sendBuffer2Size; - u32 sendWord; - struct mevent_srv_sub manager; -}; - -u32 mevent_srv_sub_recv(struct mevent_srv_sub * svr); -u32 mevent_srv_sub_send(struct mevent_srv_sub * svr); -void mevent_srv_sub_init(struct mevent_srv_sub * svr, u32 sendPlayerNo, u32 recvPlayerNo); -void mevent_srv_sub_init_send(struct mevent_srv_sub * svr, u32 ident, const void *src, u32 size); -void mevent_srv_sub_init_recv(struct mevent_srv_sub * svr, u32 ident, void *dest); - -void mevent_client_do_init(void); -u32 mevent_client_do_exec(u16 * a0); -void mevent_client_inc_flag(void); -void *mevent_client_get_buffer(void); -void mevent_client_set_param(u32 a0); -void mevent_srv_init_wnews(void); -void mevent_srv_new_wcard(void); -u32 mevent_srv_common_do_exec(u16 * a0); - -#endif //GUARD_MEVENT_SERVER_H diff --git a/include/mystery_gift.h b/include/mystery_gift.h new file mode 100644 index 000000000..c6f4210e2 --- /dev/null +++ b/include/mystery_gift.h @@ -0,0 +1,98 @@ +#ifndef GUARD_MYSTERY_GIFT_H +#define GUARD_MYSTERY_GIFT_H + +#include "global.h" +#include "main.h" +#include "constants/mystery_gift.h" + +#define CARD_STAT_BATTLES_WON 0 +#define CARD_STAT_BATTLES_LOST 1 +#define CARD_STAT_NUM_TRADES 2 +#define CARD_STAT_NUM_STAMPS 3 +#define CARD_STAT_MAX_STAMPS 4 + +enum { + NEWS_INPUT_A, + NEWS_INPUT_B, + NEWS_INPUT_SCROLL_UP, + NEWS_INPUT_SCROLL_DOWN, + NEWS_INPUT_NONE = 0xFF +}; + +struct MysteryGiftLinkGameData +{ + u32 unk_00; + u16 unk_04; + u32 unk_08; + u16 unk_0C; + u32 unk_10; + u16 flagId; + u16 questionnaireWords[NUM_QUESTIONNAIRE_WORDS]; + struct WonderCardMetadata cardMetadata; + u8 maxStamps; + u8 playerName[PLAYER_NAME_LENGTH]; + u8 playerTrainerId[TRAINER_ID_LENGTH]; + u16 easyChatProfile[EASY_CHAT_BATTLE_WORDS_COUNT]; + u8 gameCode[GAME_CODE_LENGTH]; + u8 version; +}; + +struct WonderGraphics +{ + u8 titleTextPal:4; + u8 bodyTextPal:4; + u8 footerTextPal:4; + u8 stampShadowPal:4; + const u8 * tiles; + const u8 * map; + const u16 * pal; +}; + +extern const u16 gCard1Pal[]; +extern const u16 gCard2Pal[]; +extern const u16 gCard3Pal[]; +extern const u16 gCard4Pal[]; +extern const u16 gCard5Pal[]; + +struct WonderNews * GetSavedWonderNews(void); +struct WonderCard * GetSavedWonderCard(void); +struct WonderCardMetadata * GetSavedWonderCardMetadata(void); +struct WonderNewsMetadata * GetSavedWonderNewsMetadata(void); +bool32 SaveWonderNews(const struct WonderNews * news); +bool32 ValidateSavedWonderNews(void); +bool32 ValidateSavedWonderCard(void); +bool32 IsWonderNewsSameAsSaved(const u8 * news); +bool32 SaveWonderCard(const struct WonderCard * card); +void DisableWonderCardSending(struct WonderCard * card); +bool32 MysteryGift_TrySaveStamp(const u16 * stamp); +void MysteryGift_LoadLinkGameData(struct MysteryGiftLinkGameData * data); +bool32 MysteryGift_ValidateLinkGameData(const struct MysteryGiftLinkGameData * data); +u32 MysteryGift_CompareCardFlags(const u16 * flagId, const struct MysteryGiftLinkGameData * data, const void *unused); +u32 MysteryGift_CheckStamps(const u16 * stamp, const struct MysteryGiftLinkGameData * data, const void *unused); +bool32 MysteryGift_DoesQuestionnaireMatch(const struct MysteryGiftLinkGameData * data, const u16 * words); +u16 MysteryGift_GetCardStatFromLinkData(const struct MysteryGiftLinkGameData * data, u32 stat); +bool32 WonderCard_Init(struct WonderCard * card, struct WonderCardMetadata * metadata); +bool32 WonderNews_Init(const struct WonderNews * news); +s32 WonderCard_Enter(void); +s32 WonderNews_Enter(void); +void ClearSavedWonderCardAndRelated(void); +void ClearSavedWonderNewsAndRelated(void); +void WonderCard_Destroy(void); +void WonderNews_Destroy(void); +s32 WonderCard_Exit(bool32 flag); +s32 WonderNews_Exit(bool32 flag); +bool32 IsSavedWonderCardGiftNotReceived(void); +void WonderNews_AddScrollIndicatorArrowPair(void); +void WonderNews_RemoveScrollIndicatorArrowPair(void); +bool32 IsSendingSavedWonderNewsAllowed(void); +bool32 IsSendingSavedWonderCardAllowed(void); +u32 WonderNews_GetInput(u16 input); +void ClearMysteryGift(void); +u16 MysteryGift_GetCardStat(u32 stat); +void MysteryGift_TryIncrementStat(u32 stat, u32 trainerId); +u16 *GetQuestionnaireWordsPtr(void); +void MysteryGift_DisableStats(void); +bool32 MysteryGift_TryEnableStatsByFlagId(u16 flagId); +u16 GetWonderCardFlagId(void); + +#endif // GUARD_MYSTERY_GIFT_H diff --git a/include/mystery_gift_client.h b/include/mystery_gift_client.h new file mode 100644 index 000000000..c7817d161 --- /dev/null +++ b/include/mystery_gift_client.h @@ -0,0 +1,91 @@ +#ifndef GUARD_MYSTERY_GIFT_CLIENT_H +#define GUARD_MYSTERY_GIFT_CLIENT_H + +#include "mystery_gift_link.h" + +// Return values for client functions called by MysteryGiftClient_Run +enum { + CLI_RET_INIT, + CLI_RET_ACTIVE, + CLI_RET_YES_NO, + CLI_RET_PRINT_MSG, + CLI_RET_ASK_TOSS, + CLI_RET_COPY_MSG, + CLI_RET_END, +}; + +// IDs for client script instructions +enum { + CLI_NONE, + CLI_RETURN, + CLI_RECV, + CLI_SEND_LOADED, + CLI_COPY_RECV, + CLI_YES_NO, + CLI_COPY_RECV_IF_N, + CLI_COPY_RECV_IF, + CLI_LOAD_GAME_DATA, + CLI_SAVE_NEWS, + CLI_SAVE_CARD, + CLI_PRINT_MSG, + CLI_COPY_MSG, + CLI_ASK_TOSS, + CLI_LOAD_TOSS_RESPONSE, + CLI_RUN_MEVENT_SCRIPT, + CLI_SAVE_STAMP, + CLI_SAVE_RAM_SCRIPT, + CLI_RECV_EREADER_TRAINER, + CLI_SEND_STAT, + CLI_SEND_READY_END, + CLI_RUN_BUFFER_SCRIPT, +}; + +// IDs for client messages when ending a script. +// Given as the parameter to CLI_RETURN, and resolved to text in GetClientResultMessage +enum { + CLI_MSG_NOTHING_SENT, + CLI_MSG_RECORD_UPLOADED, + CLI_MSG_CARD_RECEIVED, + CLI_MSG_NEWS_RECEIVED, + CLI_MSG_STAMP_RECEIVED, + CLI_MSG_HAD_CARD, + CLI_MSG_HAD_STAMP, + CLI_MSG_HAD_NEWS, + CLI_MSG_NO_ROOM_STAMPS, + CLI_MSG_COMM_CANCELED, + CLI_MSG_CANT_ACCEPT, + CLI_MSG_COMM_ERROR, + CLI_MSG_TRAINER_RECEIVED, + CLI_MSG_BUFFER_SUCCESS, + CLI_MSG_BUFFER_FAILURE, +}; + +#define CLIENT_MAX_MSG_SIZE 64 + +struct MysteryGiftClientCmd +{ + u32 instr; + u32 parameter; +}; + +struct MysteryGiftClient +{ + u32 unused; + u32 param; + u32 funcId; + u32 funcState; + u32 cmdidx; + void *sendBuffer; + void *recvBuffer; + struct MysteryGiftClientCmd * script; + void *msg; + struct MysteryGiftLink link; +}; + +void MysteryGiftClient_Create(void); +u32 MysteryGiftClient_Run(u16 * endVal); +void MysteryGiftClient_AdvanceState(void); +void * MysteryGiftClient_GetMsg(void); +void MysteryGiftClient_SetParam(u32 value); + +#endif //GUARD_MYSTERY_GIFT_CLIENT_H diff --git a/include/mystery_gift_link.h b/include/mystery_gift_link.h new file mode 100644 index 000000000..32100db5f --- /dev/null +++ b/include/mystery_gift_link.h @@ -0,0 +1,49 @@ +#ifndef GUARD_MYSTERY_GIFT_LINK_H +#define GUARD_MYSTERY_GIFT_LINK_H + +#define MG_LINK_BUFFER_SIZE 0x400 + +// Send/receive ids for the Client/Server to make sure +// they're sending/receiving the same thing +enum { + MG_LINKID_CLIENT_SCRIPT = 16, + MG_LINKID_GAME_DATA, + MG_LINKID_GAME_STAT, + MG_LINKID_RESPONSE, + MG_LINKID_READY_END, + MG_LINKID_DYNAMIC_MSG, + MG_LINKID_CARD, + MG_LINKID_NEWS, + MG_LINKID_STAMP, + MG_LINKID_RAM_SCRIPT, + MG_LINKID_EREADER_TRAINER, + MG_LINKID_UNK_1, + MG_LINKID_UNK_2, +}; + +struct MysteryGiftLink +{ + s32 state; + u8 sendPlayerId; + u8 recvPlayerId; + u16 recvIdent; + u16 recvCounter; + u16 recvCRC; + u16 recvSize; + u16 sendIdent; + u16 sendCounter; + u16 sendCRC; + u16 sendSize; + void * recvBuffer; + const void * sendBuffer; + u32 (*recvFunc)(struct MysteryGiftLink *); + u32 (*sendFunc)(struct MysteryGiftLink *); +}; + +void MysteryGiftLink_Init(struct MysteryGiftLink * link, u32 sendPlayerId, u32 recvPlayerId); +void MysteryGiftLink_InitSend(struct MysteryGiftLink * link, u32 ident, const void * src, u32 size); +bool32 MysteryGiftLink_Recv(struct MysteryGiftLink * link); +bool32 MysteryGiftLink_Send(struct MysteryGiftLink * link); +void MysteryGiftLink_InitRecv(struct MysteryGiftLink * link, u32 ident, void * dest); + +#endif //GUARD_MYSTERY_GIFT_LINK_H diff --git a/include/mystery_gift_menu.h b/include/mystery_gift_menu.h index 82a47fb5f..84c647c5b 100644 --- a/include/mystery_gift_menu.h +++ b/include/mystery_gift_menu.h @@ -3,9 +3,11 @@ extern bool8 gGiftIsFromEReader; +bool32 PrintMysteryGiftMenuMessage(u8 * cmdPtr, const u8 * src); +void AddTextPrinterToWindow1(const u8 *str); void MainCB_FreeAllBuffersAndReturnToInitTitleScreen(void); void PrintMysteryGiftOrEReaderTopMenu(bool8, bool32); -void c2_mystery_gift(void); +void CB2_InitMysteryGift(void); void CB2_MysteryGiftEReader(void); s8 DoMysteryGiftYesNo(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, const u8 * str); void MG_DrawTextBorder(u8 windowId); diff --git a/include/mystery_gift_server.h b/include/mystery_gift_server.h new file mode 100644 index 000000000..9832cb05a --- /dev/null +++ b/include/mystery_gift_server.h @@ -0,0 +1,104 @@ +#ifndef GUARD_MYSTERY_GIFT_SERVER_H +#define GUARD_MYSTERY_GIFT_SERVER_H + +#include "global.h" +#include "mystery_gift_link.h" + +// Return values for Server_* functions. +// Other than SVR_RET_END, effectively useless (not checked for). +enum { + SVR_RET_INIT, + SVR_RET_ACTIVE, + SVR_RET_UNUSED, + SVR_RET_END +}; + +// IDs for server script instructions +enum { + SVR_RETURN, + SVR_SEND, + SVR_RECV, + SVR_GOTO, + SVR_GOTO_IF_EQ, + SVR_COPY_GAME_DATA, + SVR_CHECK_GAME_DATA, // In Emerald, this was separated into SVR_CHECK_GAME_DATA_CARD and SVR_CHECK_GAME_DATA_NEWS + SVR_CHECK_EXISTING_CARD, + SVR_READ_RESPONSE, + SVR_CHECK_EXISTING_STAMPS, + SVR_GET_CARD_STAT, + SVR_CHECK_QUESTIONNAIRE, + SVR_COMPARE, + SVR_LOAD_CARD, + SVR_LOAD_NEWS, + SVR_LOAD_RAM_SCRIPT, + SVR_LOAD_STAMP, + SVR_LOAD_UNK_2, + SVR_LOAD_CLIENT_SCRIPT, + SVR_LOAD_EREADER_TRAINER, + SVR_LOAD_MSG, + SVR_COPY_STAMP, + SVR_COPY_CARD, + SVR_COPY_NEWS, + SVR_SET_RAM_SCRIPT, + SVR_SET_CLIENT_SCRIPT, + SVR_COPY_SAVED_CARD, + SVR_COPY_SAVED_NEWS, + SVR_COPY_SAVED_RAM_SCRIPT, + SVR_LOAD_UNK_1, +}; + +// Create arguments for SVR_LOAD_CLIENT_SCRIPT or SVR_LOAD_MSG +// (a script/text size and pointer to send to the client) +#define PTR_ARG(pointer) .param = sizeof(pointer), .ptr = pointer + +// IDs for server messages when ending a script. +// Given as the parameter to SVR_RETURN, and resolved to text in GetServerResultMessage +enum { + SVR_MSG_NOTHING_SENT, + SVR_MSG_RECORD_UPLOADED, + SVR_MSG_CARD_SENT, + SVR_MSG_NEWS_SENT, + SVR_MSG_STAMP_SENT, + SVR_MSG_HAS_CARD, + SVR_MSG_HAS_STAMP, + SVR_MSG_HAS_NEWS, + SVR_MSG_NO_ROOM_STAMPS, + SVR_MSG_CLIENT_CANCELED, + SVR_MSG_CANT_SEND_GIFT_1, + SVR_MSG_COMM_ERROR, + SVR_MSG_GIFT_SENT_1, + SVR_MSG_GIFT_SENT_2, + SVR_MSG_CANT_SEND_GIFT_2, +}; + +struct MysteryGiftServerCmd +{ + u32 instr; + bool32 param; + const void *ptr; +}; + +struct MysteryGiftServer +{ + u32 unused; + u32 param; + u32 funcId; + u32 cmdidx; + const struct MysteryGiftServerCmd * script; + void *recvBuffer; + struct WonderCard * card; + struct WonderNews * news; + struct MysteryGiftLinkGameData * linkGameData; + const void *ramScript; + u32 ramScriptSize; + const void *clientScript; + u32 clientScriptSize; + u32 stamp; + struct MysteryGiftLink manager; +}; + +void MysterGiftServer_CreateForNews(void); +void MysterGiftServer_CreateForCard(void); +u32 MysterGiftServer_Run(u16 * endVal); + +#endif //GUARD_MYSTERY_GIFT_SERVER_H diff --git a/include/strings.h b/include/strings.h index 0d1fe4afa..8326616b0 100644 --- a/include/strings.h +++ b/include/strings.h @@ -1141,7 +1141,7 @@ extern const u8 gText_PeopleBattling[]; extern const u8 gText_PeopleInUnionRoom[]; extern const u8 gText_PeopleCommunicating[]; -// mevent +// mystery_gift extern const u8 gJPText_ReceiveMysteryGiftWithEReader[]; extern const u8 gJPText_SelectConnectFromEReaderMenu[]; extern const u8 gJPText_SelectConnectWithGBA[]; diff --git a/include/wonder_news.h b/include/wonder_news.h new file mode 100644 index 000000000..3cbb46055 --- /dev/null +++ b/include/wonder_news.h @@ -0,0 +1,17 @@ +#ifndef GUARD_WONDER_NEWS_H +#define GUARD_WONDER_NEWS_H + +#include "global.h" + +enum { + WONDER_NEWS_NONE, + WONDER_NEWS_RECV_FRIEND, + WONDER_NEWS_RECV_WIRELESS, + WONDER_NEWS_SENT, +}; + +void WonderNews_SetReward(u32 newsType); +void WonderNews_Reset(void); +void WonderNews_IncrementStepCounter(void); + +#endif //GUARD_WONDER_NEWS_H diff --git a/ld_script.txt b/ld_script.txt index 5c7a3751d..54c794e52 100644 --- a/ld_script.txt +++ b/ld_script.txt @@ -275,13 +275,14 @@ SECTIONS { src/slot_machine.o(.text); src/roamer.o(.text); src/mystery_gift_menu.o(.text); - src/mevent.o(.text); - src/mevent_server_helpers.o(.text); - src/mevent_client.o(.text); - src/mevent_server.o(.text); + src/ereader_screen.o(.text); + src/mystery_gift.o(.text); + src/mystery_gift_link.o(.text); + src/mystery_gift_client.o(.text); + src/mystery_gift_server.o(.text); src/mystery_gift_show_card.o(.text); src/mystery_gift_show_news.o(.text); - src/menews_jisan.o(.text); + src/wonder_news.o(.text); src/seagallop.o(.text); src/pokemon_jump.o(.text); src/berry_crush.o(.text); @@ -568,15 +569,16 @@ SECTIONS { src/slot_machine.o(.rodata); src/roamer.o(.rodata); src/mystery_gift_menu.o(.rodata); - src/mevent.o(.rodata); - src/mevent_server_helpers.o(.rodata); - src/mevent_client.o(.rodata); - src/mevent_server.o(.rodata); + src/ereader_screen.o(.rodata); + src/mystery_gift.o(.rodata); + src/mystery_gift_link.o(.rodata); + src/mystery_gift_client.o(.rodata); + src/mystery_gift_server.o(.rodata); src/mystery_gift_show_card.o(.rodata); src/mystery_gift_show_news.o(.rodata); - src/mevent_scripts.o(.rodata); - src/menews_jisan.o(.rodata); - src/menews_jisan.o(.rodata.str1.4); + src/mystery_gift_scripts.o(.rodata); + src/wonder_news.o(.rodata); + src/wonder_news.o(.rodata.str1.4); src/seagallop.o(.rodata); src/pokemon_jump.o(.rodata); src/berry_crush.o(.rodata); diff --git a/src/cable_club.c b/src/cable_club.c index b3fbc1f78..730b42d3d 100644 --- a/src/cable_club.c +++ b/src/cable_club.c @@ -10,7 +10,7 @@ #include "link.h" #include "load_save.h" #include "m4a.h" -#include "mevent.h" +#include "mystery_gift.h" #include "new_menu_helpers.h" #include "overworld.h" #include "quest_log.h" diff --git a/src/easy_chat.c b/src/easy_chat.c index 096bda634..4a08a1afb 100644 --- a/src/easy_chat.c +++ b/src/easy_chat.c @@ -4,7 +4,7 @@ #include "easy_chat.h" #include "event_data.h" #include "field_message_box.h" -#include "mevent.h" +#include "mystery_gift.h" #include "menu.h" #include "mail.h" #include "pokedex.h" @@ -472,11 +472,11 @@ void InitEasyChatPhrases(void) #endif } -void EC_ResetMEventProfileMaybe(void) +void InitQuestionnaireWords(void) { s32 i; - u16 *ptr = GetMEventProfileECWordsMaybe(); - for (i = 0; i < 4; i++) + u16 *ptr = GetQuestionnaireWordsPtr(); + for (i = 0; i < NUM_QUESTIONNAIRE_WORDS; i++) ptr[i] = EC_WORD_UNDEFINED; } diff --git a/src/easy_chat_2.c b/src/easy_chat_2.c index 5a3c9a7cb..6951da8e8 100644 --- a/src/easy_chat_2.c +++ b/src/easy_chat_2.c @@ -3,7 +3,7 @@ #include "easy_chat.h" #include "event_data.h" #include "menu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "overworld.h" #include "strings.h" #include "task.h" @@ -271,7 +271,7 @@ void ShowEasyChatScreen(void) words = gSaveBlock1Ptr->easyChatBattleLost; break; case EASY_CHAT_TYPE_QUESTIONNAIRE: - words = GetMEventProfileECWordsMaybe(); + words = GetQuestionnaireWordsPtr(); break; case EASY_CHAT_TYPE_MAIL: words = gSaveBlock1Ptr->mail[gSpecialVar_0x8005].words; diff --git a/src/ereader_screen.c b/src/ereader_screen.c new file mode 100644 index 000000000..060150cbf --- /dev/null +++ b/src/ereader_screen.c @@ -0,0 +1,520 @@ +#include "global.h" +#include "malloc.h" +#include "decompress.h" +#include "ereader_helpers.h" +#include "link.h" +#include "main.h" +#include "mystery_gift_menu.h" +#include "mystery_gift_client.h" +#include "save.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "strings.h" +#include "util.h" +#include "cereader_tool.h" +#include "help_system.h" +#include "constants/songs.h" + +struct EReaderTaskData +{ + u16 timer; + u16 unused1; + u16 unused2; + u16 unused3; + u8 state; + u8 textState; + u8 unused4; + u8 unused5; + u8 unused6; + u8 unused7; + u8 status; + u8 *unusedBuffer; +}; + +struct EReaderData +{ + u16 status; + size_t size; + const void *data; +}; + +static void Task_EReader(u8); + +struct EReaderData gEReaderData; + +extern const u8 gMultiBootProgram_EReader_Start[]; +extern const u8 gMultiBootProgram_EReader_End[]; + +static void EReader_Load(struct EReaderData *eReader, size_t size, const void *data) +{ + vu16 imeBak = REG_IME; + REG_IME = 0; + gIntrTable[1] = EReaderHelper_SerialCallback; + gIntrTable[2] = EReaderHelper_Timer3Callback; + EReaderHelper_SaveRegsState(); + EReaderHelper_ClearsSendRecvMgr(); + REG_IE |= INTR_FLAG_VCOUNT; + REG_IME = imeBak; + eReader->status = 0; + eReader->size = size; + eReader->data = data; +} + +static void EReader_Reset(struct EReaderData *eReader) +{ + vu16 imeBak = REG_IME; + REG_IME = 0; + EReaderHelper_ClearsSendRecvMgr(); + EReaderHelper_RestoreRegsState(); + RestoreSerialTimer3IntrHandlers(); + REG_IME = imeBak; +} + +// Return values for EReader_Transfer +enum { + TRANSFER_ACTIVE, + TRANSFER_SUCCESS, + TRANSFER_CANCELED, + TRANSFER_TIMEOUT, +}; + +static u8 EReader_Transfer(struct EReaderData *eReader) +{ + u8 transferStatus = TRANSFER_ACTIVE; + eReader->status = EReaderHandleTransfer(TRUE, eReader->size, eReader->data, NULL); + + if ((eReader->status & EREADER_XFER_MASK) == 0 && eReader->status & EREADER_CHECKSUM_OK_MASK) + transferStatus = TRANSFER_SUCCESS; + + if (eReader->status & EREADER_CANCEL_KEY_MASK) + transferStatus = TRANSFER_CANCELED; + + if (eReader->status & EREADER_CANCEL_TIMEOUT_MASK) + transferStatus = TRANSFER_TIMEOUT; + + gShouldAdvanceLinkState = 0; + return transferStatus; +} + +static void OpenEReaderLink(void) +{ + memset(gDecompressionBuffer, 0, 0x2000); + gLinkType = LINKTYPE_EREADER_FRLG; + OpenLink(); + SetSuppressLinkErrorMessage(TRUE); +} + +static bool32 ValidateEReaderConnection(void) +{ + vu16 imeBak = REG_IME; + u16 handshakes[MAX_LINK_PLAYERS]; + + REG_IME = 0; + *(u64 *)handshakes = *(u64 *)gLink.tempRecvBuffer; + REG_IME = imeBak; + + // Validate that we are player 1, the EReader is player 2, + // and that players 3 and 4 are empty. + if (handshakes[0] == SLAVE_HANDSHAKE + && handshakes[1] == EREADER_HANDSHAKE + && handshakes[2] == 0xFFFF + && handshakes[3] == 0xFFFF) + return TRUE; + return FALSE; +} + +static bool32 IsEReaderConnectionSane(void) +{ + if (IsLinkMaster() && GetLinkPlayerCount_2() == 2) + return TRUE; + return FALSE; +} + +// States for TryReceiveCard +enum { + RECV_STATE_INIT, + RECV_STATE_WAIT_START, + RECV_STATE_START, + RECV_STATE_EXCHANGE, + RECV_STATE_START_DISCONNECT, + RECV_STATE_WAIT_DISCONNECT, +}; + +// Return values for TryReceiveCard +enum { + RECV_ACTIVE, + RECV_CANCELED, + RECV_SUCCESS, + RECV_ERROR, + RECV_DISCONNECTED, + RECV_TIMEOUT, +}; + +static u32 TryReceiveCard(u8 * state, u16 * timer) +{ + if ((*state == RECV_STATE_EXCHANGE + || *state == RECV_STATE_START_DISCONNECT + || *state == RECV_STATE_WAIT_DISCONNECT) + && HasLinkErrorOccurred()) + { + // Return error status if an error occurs + // during the link exchange. + *state = 0; + return RECV_ERROR; + } + + switch (*state) + { + case RECV_STATE_INIT: + if (IsLinkMaster() && GetLinkPlayerCount_2() > 1) + { + *state = RECV_STATE_WAIT_START; + } + else if (JOY_NEW(B_BUTTON)) + { + *state = 0; + return RECV_CANCELED; + } + break; + case RECV_STATE_WAIT_START: + if (++(*timer) > 5) + { + *timer = 0; + *state = RECV_STATE_START; + } + break; + case RECV_STATE_START: + if (GetLinkPlayerCount_2() == 2) + { + PlaySE(SE_DING_DONG); + CheckShouldAdvanceLinkState(); + *timer = 0; + *state = RECV_STATE_EXCHANGE; + } + else if (JOY_NEW(B_BUTTON)) + { + *state = 0; + return RECV_CANCELED; + } + break; + case RECV_STATE_EXCHANGE: + if (++(*timer) > 30) + { + *state = 0; + return RECV_TIMEOUT; + } + + if (IsLinkConnectionEstablished()) + { + if (gReceivedRemoteLinkPlayers) + { + if (IsLinkPlayerDataExchangeComplete()) + { + *state = 0; + return RECV_SUCCESS; + } + else + *state = RECV_STATE_START_DISCONNECT; + } + else + *state = RECV_STATE_EXCHANGE; + } + break; + case RECV_STATE_START_DISCONNECT: + SetCloseLinkCallbackAndType(0); + *state = RECV_STATE_WAIT_DISCONNECT; + break; + case RECV_STATE_WAIT_DISCONNECT: + if (!gReceivedRemoteLinkPlayers) + { + *state = 0; + return RECV_DISCONNECTED; + } + break; + } + return RECV_ACTIVE; +} + +void CreateEReaderTask(void) +{ + u8 taskId = CreateTask(Task_EReader, 0); + struct EReaderTaskData *data = (struct EReaderTaskData *)gTasks[taskId].data; + data->state = 0; + data->textState = 0; + data->unused4 = 0; + data->unused5 = 0; + data->unused6 = 0; + data->unused7 = 0; + data->timer = 0; + data->unused1 = 0; + data->unused2 = 0; + data->unused3 = 0; + data->status = 0; + data->unusedBuffer = AllocZeroed(CLIENT_MAX_MSG_SIZE); +} + +static void ResetTimer(u16 *timer) +{ + *timer = 0; +} + +static bool32 UpdateTimer(u16 * timer, u16 time) +{ + if (++(*timer) > time) + { + // Timer has finished + *timer = 0; + return TRUE; + } + return FALSE; +} + +// States for Task_EReader +enum { + ER_STATE_START, + ER_STATE_INIT_LINK, + ER_STATE_INIT_LINK_WAIT, + ER_STATE_INIT_LINK_CHECK, + ER_STATE_MSG_SELECT_CONNECT, + ER_STATE_MSG_SELECT_CONNECT_WAIT, + ER_STATE_TRY_LINK, + ER_STATE_INCORRECT_LINK, + ER_STATE_CONNECTING, + ER_STATE_TRANSFER, + ER_STATE_TRANSFER_END, + ER_STATE_TRANSFER_SUCCESS, + ER_STATE_LOAD_CARD_START, + ER_STATE_LOAD_CARD, + ER_STATE_WAIT_RECV_CARD, + ER_STATE_VALIDATE_CARD, + ER_STATE_WAIT_DISCONNECT, + ER_STATE_SAVE, + ER_STATE_SUCCESS_MSG, + ER_STATE_SUCCESS_END, + ER_STATE_LINK_ERROR, + ER_STATE_LINK_ERROR_TRY_AGAIN, + ER_STATE_SAVE_FAILED, + ER_STATE_CANCELED_CARD_READ, + ER_STATE_UNUSED_1, + ER_STATE_UNUSED_2, + ER_STATE_END, +}; + +static void Task_EReader(u8 taskId) +{ + struct EReaderTaskData *data = (struct EReaderTaskData *)gTasks[taskId].data; + switch (data->state) + { + case ER_STATE_START: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_ReceiveMysteryGiftWithEReader)) + data->state = ER_STATE_INIT_LINK; + break; + case ER_STATE_INIT_LINK: + OpenEReaderLink(); + ResetTimer(&data->timer); + data->state = ER_STATE_INIT_LINK_WAIT; + break; + case ER_STATE_INIT_LINK_WAIT: + if (UpdateTimer(&data->timer, 10)) + data->state = ER_STATE_INIT_LINK_CHECK; + break; + case ER_STATE_INIT_LINK_CHECK: + if (!IsEReaderConnectionSane()) + { + CloseLink(); + data->state = ER_STATE_MSG_SELECT_CONNECT; + } + else + data->state = ER_STATE_LOAD_CARD; + break; + case ER_STATE_MSG_SELECT_CONNECT: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_SelectConnectFromEReaderMenu)) + { + AddTextPrinterToWindow1(gJPText_SelectConnectWithGBA); + ResetTimer(&data->timer); + data->state = ER_STATE_MSG_SELECT_CONNECT_WAIT; + } + break; + case ER_STATE_MSG_SELECT_CONNECT_WAIT: + if (UpdateTimer(&data->timer, 90)) + { + OpenEReaderLink(); + data->state = ER_STATE_TRY_LINK; + } + else if (JOY_NEW(B_BUTTON)) + { + ResetTimer(&data->timer); + PlaySE(SE_SELECT); + data->state = ER_STATE_CANCELED_CARD_READ; + } + break; + case ER_STATE_TRY_LINK: + if (JOY_NEW(B_BUTTON)) + { + // Canceled + PlaySE(SE_SELECT); + CloseLink(); + ResetTimer(&data->timer); + data->state = ER_STATE_CANCELED_CARD_READ; + } + else if (GetLinkPlayerCount_2() > 1) + { + ResetTimer(&data->timer); + CloseLink(); + data->state = ER_STATE_INCORRECT_LINK; + } + else if (ValidateEReaderConnection()) + { + // Successful connection + PlaySE(SE_SELECT); + CloseLink(); + ResetTimer(&data->timer); + data->state = ER_STATE_CONNECTING; + } + else if (UpdateTimer(&data->timer, 10)) + { + // Retry connection + CloseLink(); + OpenEReaderLink(); + ResetTimer(&data->timer); + } + break; + case ER_STATE_INCORRECT_LINK: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_LinkIsIncorrect)) + data->state = ER_STATE_MSG_SELECT_CONNECT; + break; + case ER_STATE_CONNECTING: + AddTextPrinterToWindow1(gJPText_Connecting); + EReader_Load(&gEReaderData, gMultiBootProgram_EReader_End - gMultiBootProgram_EReader_Start, gMultiBootProgram_EReader_Start); + data->state = ER_STATE_TRANSFER; + break; + case ER_STATE_TRANSFER: + data->status = EReader_Transfer(&gEReaderData); + if (data->status != TRANSFER_ACTIVE) + data->state = ER_STATE_TRANSFER_END; + break; + case ER_STATE_TRANSFER_END: + EReader_Reset(&gEReaderData); + if (data->status == TRANSFER_TIMEOUT) + { + data->state = ER_STATE_LINK_ERROR; + } + else if (data->status == TRANSFER_SUCCESS) + { + ResetTimer(&data->timer); + AddTextPrinterToWindow1(gJPText_PleaseWaitAMoment); + data->state = ER_STATE_TRANSFER_SUCCESS; + } + else // TRANSFER_CANCELED + { + data->state = ER_STATE_START; + } + break; + case ER_STATE_TRANSFER_SUCCESS: + if (UpdateTimer(&data->timer, 840)) + data->state = ER_STATE_LOAD_CARD_START; + break; + case ER_STATE_LOAD_CARD_START: + OpenEReaderLink(); + AddTextPrinterToWindow1(gJPText_AllowEReaderToLoadCard); + data->state = ER_STATE_LOAD_CARD; + break; + case ER_STATE_LOAD_CARD: + switch (TryReceiveCard(&data->textState, &data->timer)) + { + case RECV_ACTIVE: + // Running + break; + case RECV_SUCCESS: + AddTextPrinterToWindow1(gJPText_Connecting); + data->state = ER_STATE_WAIT_RECV_CARD; + break; + case RECV_CANCELED: + PlaySE(SE_SELECT); + CloseLink(); + data->state = ER_STATE_CANCELED_CARD_READ; + break; + case RECV_TIMEOUT: + CloseLink(); + data->state = ER_STATE_LINK_ERROR_TRY_AGAIN; + break; + case RECV_ERROR: + case RECV_DISCONNECTED: + CloseLink(); + data->state = ER_STATE_LINK_ERROR; + break; + } + break; + case ER_STATE_WAIT_RECV_CARD: + if (HasLinkErrorOccurred()) + { + CloseLink(); + data->state = ER_STATE_LINK_ERROR; + } + else if (GetBlockReceivedStatus()) + { + ResetBlockReceivedFlags(); + data->state = ER_STATE_VALIDATE_CARD; + } + break; + case ER_STATE_VALIDATE_CARD: + data->status = ValidateTrainerTowerData((struct EReaderTrainerTowerSet *)gDecompressionBuffer); + SetCloseLinkCallbackAndType(data->status); + data->state = ER_STATE_WAIT_DISCONNECT; + break; + case ER_STATE_WAIT_DISCONNECT: + if (!gReceivedRemoteLinkPlayers) + { + if (data->status == TRUE) // Was data valid? + data->state = ER_STATE_SAVE; + else + data->state = ER_STATE_LINK_ERROR; + } + break; + case ER_STATE_SAVE: + if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerTowerSet *)gDecompressionBuffer)) + { + AddTextPrinterToWindow1(gJPText_ConnectionComplete); + ResetTimer(&data->timer); + data->state = ER_STATE_SUCCESS_MSG; + } + else + data->state = ER_STATE_SAVE_FAILED; + break; + case ER_STATE_SUCCESS_MSG: + if (UpdateTimer(&data->timer, 120)) + { + AddTextPrinterToWindow1(gJPText_NewTrainerHasComeToSevii); + PlayFanfare(MUS_OBTAIN_ITEM); + data->state = ER_STATE_SUCCESS_END; + } + break; + case ER_STATE_SUCCESS_END: + if (IsFanfareTaskInactive() && JOY_NEW(A_BUTTON | B_BUTTON)) + data->state = ER_STATE_END; + break; + case ER_STATE_CANCELED_CARD_READ: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_CardReadingHasBeenHalted)) + data->state = ER_STATE_END; + break; + case ER_STATE_LINK_ERROR: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_ConnectionErrorCheckLink)) + data->state = ER_STATE_START; + break; + case ER_STATE_LINK_ERROR_TRY_AGAIN: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_ConnectionErrorTryAgain)) + data->state = ER_STATE_START; + break; + case ER_STATE_SAVE_FAILED: + if (PrintMysteryGiftMenuMessage(&data->textState, gJPText_WriteErrorUnableToSaveData)) + data->state = ER_STATE_START; + break; + case ER_STATE_END: + HelpSystem_Enable(); + Free(data->unusedBuffer); + DestroyTask(taskId); + SetMainCallback2(MainCB_FreeAllBuffersAndReturnToInitTitleScreen); + break; + } +} diff --git a/src/event_data.c b/src/event_data.c index 5d3bad5d6..13ec93917 100644 --- a/src/event_data.c +++ b/src/event_data.c @@ -129,7 +129,7 @@ bool32 IsMysteryGiftEnabled(void) return FlagGet(FLAG_SYS_MYSTERY_GIFT_ENABLED); } -void ResetMysteryEventFlags(void) +void ClearMysteryGiftFlags(void) { FlagClear(FLAG_MYSTERY_GIFT_DONE); FlagClear(FLAG_MYSTERY_GIFT_1); @@ -149,7 +149,7 @@ void ResetMysteryEventFlags(void) FlagClear(FLAG_MYSTERY_GIFT_15); } -void ResetMysteryEventVars(void) +void ClearMysteryGiftVars(void) { VarSet(VAR_EVENT_PICHU_SLOT, 0); VarSet(VAR_MYSTERY_GIFT_1, 0); diff --git a/src/field_control_avatar.c b/src/field_control_avatar.c index 615a70e60..31dd27e17 100644 --- a/src/field_control_avatar.c +++ b/src/field_control_avatar.c @@ -14,7 +14,7 @@ #include "field_specials.h" #include "item_menu.h" #include "link.h" -#include "menews_jisan.h" +#include "wonder_news.h" #include "metatile_behavior.h" #include "overworld.h" #include "renewable_hidden_items.h" @@ -215,7 +215,7 @@ int ProcessPlayerFieldInput(struct FieldInput *input) if (input->tookStep) { IncrementGameStat(GAME_STAT_STEPS); - MENewsJisanStepCounter(); + WonderNews_IncrementStepCounter(); IncrementRenewableHiddenItemStepCounter(); RunMassageCooldownStepCounter(); IncrementResortGorgeousStepCounter(); diff --git a/src/field_specials.c b/src/field_specials.c index 84ffd75e3..331a32b15 100644 --- a/src/field_specials.c +++ b/src/field_specials.c @@ -28,7 +28,7 @@ #include "pokedex.h" #include "text_window.h" #include "menu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "naming_screen.h" #include "party_menu.h" #include "dynamic_placeholder_text_util.h" @@ -1950,20 +1950,20 @@ void QuestLog_TryRecordDepartedLocation(void) } } -u16 BattleCardAction(void) +u16 GetMysteryGiftCardStat(void) { switch (gSpecialVar_Result) { - case 0: - return MEvent_GetBattleCardCount(3); - case 1: - return MEvent_GetBattleCardCount(4); - case 2: - return MEvent_GetBattleCardCount(0); - case 3: - return MEvent_GetBattleCardCount(1); - case 4: - return MEvent_GetBattleCardCount(2); + case GET_NUM_STAMPS: + return MysteryGift_GetCardStat(CARD_STAT_NUM_STAMPS); + case GET_MAX_STAMPS: + return MysteryGift_GetCardStat(CARD_STAT_MAX_STAMPS); + case GET_CARD_BATTLES_WON: + return MysteryGift_GetCardStat(CARD_STAT_BATTLES_WON); + case GET_CARD_BATTLES_LOST: + return MysteryGift_GetCardStat(CARD_STAT_BATTLES_LOST); + case GET_CARD_NUM_TRADES: + return MysteryGift_GetCardStat(CARD_STAT_NUM_TRADES); default: AGB_ASSERT_EX(0, ABSPATH("scr_tool.c"), 3873); return 0; diff --git a/src/main_menu.c b/src/main_menu.c index 011bc2308..94fcb7ac6 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -481,7 +481,7 @@ static void Task_ExecuteMainMenuSelection(u8 taskId) TrySetUpQuestLogScenes_ElseContinueFromSave(taskId); break; case MAIN_MENU_MYSTERYGIFT: - SetMainCallback2(c2_mystery_gift); + SetMainCallback2(CB2_InitMysteryGift); HelpSystem_Disable(); FreeAllWindowBuffers(); DestroyTask(taskId); diff --git a/src/menews_jisan.c b/src/menews_jisan.c deleted file mode 100644 index d8d4af917..000000000 --- a/src/menews_jisan.c +++ /dev/null @@ -1,148 +0,0 @@ -#include "global.h" -#include "mevent.h" -#include "random.h" -#include "event_data.h" -#include "menews_jisan.h" -#include "constants/items.h" - -static u32 GetMENewsJisanRewardItem(struct WonderNewsMetadata *); -static void MENewsJisanIncrementCounterUnk0_5(struct WonderNewsMetadata *); -static u32 GetMENewsJisanState(struct WonderNewsMetadata *); -static void MENewsJisanIncrementCounterUnk0_2(struct WonderNewsMetadata *); -static void MENewsJisanResetCounterUnk0_2(struct WonderNewsMetadata *); - -void MENewsJisan_SetRandomReward(u32 a0) -{ - struct WonderNewsMetadata *r5 = GetMENewsJisanStructPtr(); - - r5->unk_0_0 = a0; - switch (a0) - { - case 0: - break; - case 1: - case 2: - r5->berry = (Random() % 15) + ITEM_TO_BERRY(ITEM_RAZZ_BERRY); - break; - case 3: - r5->berry = (Random() % 15) + ITEM_TO_BERRY(ITEM_CHERI_BERRY); - break; - } -} - -void MENewsJisanReset(void) -{ - struct WonderNewsMetadata *r5 = GetMENewsJisanStructPtr(); - - r5->unk_0_0 = 0; - r5->unk_0_2 = 0; - r5->unk_0_5 = 0; - r5->berry = 0; - VarSet(VAR_MENEWS_JISAN_STEP_COUNTER, 0); -} - -void MENewsJisanStepCounter(void) -{ - u16 *r4 = GetVarPointer(VAR_MENEWS_JISAN_STEP_COUNTER); - struct WonderNewsMetadata *r2 = GetMENewsJisanStructPtr(); - struct WonderNewsMetadata r0 = *r2; - - if ((u8)r0.unk_0_5 > 4 && ++(*r4) >= 500) - { - r2->unk_0_5 = 0; - *r4 = 0; - } -} - -u16 GetMENewsJisanItemAndState(void) -{ - u16 *r6 = &gSpecialVar_Result; - struct WonderNewsMetadata *r4 = GetMENewsJisanStructPtr(); - u16 r5; - - if (!IsMysteryGiftEnabled() || !ValidateReceivedWonderNews()) - return 0; - - r5 = GetMENewsJisanState(r4); - - switch (r5) - { - case 0: - break; - case 1: - *r6 = GetMENewsJisanRewardItem(r4); - break; - case 2: - *r6 = GetMENewsJisanRewardItem(r4); - break; - case 3: - break; - case 4: - *r6 = GetMENewsJisanRewardItem(r4); - MENewsJisanIncrementCounterUnk0_2(r4); - break; - case 5: - *r6 = GetMENewsJisanRewardItem(r4); - MENewsJisanResetCounterUnk0_2(r4); - break; - case 6: - break; - } - - return r5; -} - -static u32 GetMENewsJisanRewardItem(struct WonderNewsMetadata *a0) -{ - u32 r4; - - a0->unk_0_0 = 0; - r4 = a0->berry + FIRST_BERRY_INDEX - 1; - a0->berry = 0; - MENewsJisanIncrementCounterUnk0_5(a0); - return r4; -} - -static void MENewsJisanResetCounterUnk0_2(struct WonderNewsMetadata *a0) -{ - a0->unk_0_2 = 0; -} - -static void MENewsJisanIncrementCounterUnk0_2(struct WonderNewsMetadata *a0) -{ - a0->unk_0_2++; - if ((u8)a0->unk_0_2 > 4) - a0->unk_0_2 = 4; -} - -static void MENewsJisanIncrementCounterUnk0_5(struct WonderNewsMetadata *a0) -{ - a0->unk_0_5++; - if ((u8)a0->unk_0_5 > 5) - a0->unk_0_5 = 5; -} - -static u32 GetMENewsJisanState(struct WonderNewsMetadata *a0) -{ - struct WonderNewsMetadata r0; - if ((u8)a0->unk_0_5 == 5) - return 6; - - r0 = *a0; - switch (r0.unk_0_0) - { - case 0: - return 3; - case 1: - return 1; - case 2: - return 2; - case 3: - if ((u8)r0.unk_0_2 < 3) - return 4; - return 5; - default: - AGB_ASSERT_EX(0, ABSPATH("menews_jisan.c"), 383); - return 0; - } -} diff --git a/src/mevent.c b/src/mevent.c deleted file mode 100644 index 984c792b3..000000000 --- a/src/mevent.c +++ /dev/null @@ -1,1029 +0,0 @@ -#include "global.h" -#include "gflib.h" -#include "constants/songs.h" -#include "easy_chat.h" -#include "task.h" -#include "decompress.h" -#include "link.h" -#include "link_rfu.h" -#include "ereader_helpers.h" -#include "util.h" -#include "script.h" -#include "event_data.h" -#include "battle_tower.h" -#include "new_game.h" -#include "menews_jisan.h" -#include "cereader_tool.h" -#include "mystery_gift_menu.h" -#include "help_system.h" -#include "mevent.h" -#include "strings.h" - -struct MEventTaskData1 -{ - u16 stateAdvanceDelay; - u16 t02; - u16 t04; - u16 t06; - u8 state; - u8 textOrReceiveState; - u8 t0A; - u8 t0B; - u8 t0C; - u8 t0D; - u8 initialSendResult; - struct MEvent_Str_2 *t10; -}; - -static void Task_EReaderComm(u8 taskId); -static bool32 IsReceivedWonderNewsHeaderValid(const struct WonderNews * src); -static void BlankWonderNews(void); -static void BlankMENewsJisan(void); -static bool32 IsReceivedWonderCardHeaderValid(const struct WonderCard * src); -static void BlankSavedWonderCard(void); -static void BlankMEventBuffer2(void); -static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 *idsList, s32 count); -static void BlankBuffer344(void); - -extern const u8 gMultiBootProgram_EReader_Start[]; -extern const u8 gMultiBootProgram_EReader_End[]; - -static const u16 sGiftItemFlagIds[] = { - FLAG_GOT_AURORA_TICKET, - FLAG_GOT_MYSTIC_TICKET, - FLAG_0x2A9, - FLAG_0x2AA, - FLAG_0x2AB, - FLAG_0x2AC, - FLAG_0x2AD, - FLAG_0x2AE, - FLAG_0x2AF, - FLAG_0x2B0, - FLAG_0x2B1, - FLAG_0x2B2, - FLAG_0x2B3, - FLAG_0x2B4, - FLAG_0x2B5, - FLAG_0x2B6, - FLAG_0x2B7, - FLAG_0x2B8, - FLAG_0x2B9, - FLAG_0x2BA -}; - -struct MEvent_Str_1 sMEventSendToEReaderManager; - -static EWRAM_DATA bool32 sReceivedWonderCardIsValid = FALSE; - -void SendUnknownSerialData_Init(struct MEvent_Str_1 *mgr, size_t size, const void *data) -{ - vu16 imeBak = REG_IME; - REG_IME = 0; - gIntrTable[1] = EReaderHelper_SerialCallback; - gIntrTable[2] = EReaderHelper_Timer3Callback; - EReaderHelper_SaveRegsState(); - EReaderHelper_ClearsSendRecvMgr(); - REG_IE |= INTR_FLAG_VCOUNT; - REG_IME = imeBak; - mgr->status = 0; - mgr->size = size; - mgr->data = data; -} - -void SendUnknownSerialData_Teardown(struct MEvent_Str_1 *unused) -{ - vu16 imeBak = REG_IME; - REG_IME = 0; - EReaderHelper_ClearsSendRecvMgr(); - EReaderHelper_RestoreRegsState(); - RestoreSerialTimer3IntrHandlers(); - REG_IME = imeBak; -} - -u8 SendUnknownSerialData_Run(struct MEvent_Str_1 *mgr) -{ - u8 resp = 0; - mgr->status = EReaderHandleTransfer(1, mgr->size, mgr->data, 0); - if ((mgr->status & 0x13) == 0x10) // checksum OK and xfer off - resp = 1; - if (mgr->status & 8) // cancelled by player - resp = 2; - if (mgr->status & 4) // timed out - resp = 3; - gShouldAdvanceLinkState = 0; - return resp; -} - -static void ResetTTDataBuffer(void) -{ - memset(gDecompressionBuffer, 0, 0x2000); - gLinkType = 0x5502; - OpenLink(); - SetSuppressLinkErrorMessage(TRUE); -} - -bool32 sub_81436EC(void) -{ - vu16 imeBak = REG_IME; - u16 data[4]; - REG_IME = 0; - *(u64 *)data = *(u64 *)gLink.tempRecvBuffer; - REG_IME = imeBak; - if ( data[0] == 0xB9A0 - && data[1] == 0xCCD0 - && data[2] == 0xFFFF - && data[3] == 0xFFFF - ) - return TRUE; - return FALSE; -} - -static bool32 IsEReaderConnectionSane(void) -{ - if (IsLinkMaster() && GetLinkPlayerCount_2() == 2) - return TRUE; - return FALSE; -} - -static u32 EReaderReceive(u8 * state_p, u16 * receiveDelay) -{ - if ((*state_p == 3 || *state_p == 4 || *state_p == 5) && HasLinkErrorOccurred()) - { - *state_p = 0; - return 3; - } - switch (*state_p) - { - case 0: - if (IsLinkMaster() && GetLinkPlayerCount_2() > 1) - { - *state_p = 1; - ; - } - else if (JOY_NEW(B_BUTTON)) - { - *state_p = 0; - return 1; - } - break; - case 1: - if (++(*receiveDelay) > 5) - { - *receiveDelay = 0; - *state_p = 2; - } - break; - case 2: - if (GetLinkPlayerCount_2() == 2) - { - PlaySE(SE_DING_DONG); - CheckShouldAdvanceLinkState(); - *receiveDelay = 0; - *state_p = 3; - } - else if (JOY_NEW(B_BUTTON)) - { - *state_p = 0; - return 1; - } - break; - case 3: - if (++(*receiveDelay) > 30) - { - *state_p = 0; - return 5; - } - else if (IsLinkConnectionEstablished()) - { - if (gReceivedRemoteLinkPlayers) - { - if (IsLinkPlayerDataExchangeComplete()) - { - *state_p = 0; - return 2; - } - else - *state_p = 4; - } - else - *state_p = 3; - } - break; - case 4: - SetCloseLinkCallbackAndType(0); - *state_p = 5; - break; - case 5: - if (!gReceivedRemoteLinkPlayers) - { - *state_p = 0; - return 4; - } - break; - } - return 0; -} - -void task_add_00_ereader(void) -{ - u8 taskId = CreateTask(Task_EReaderComm, 0); - struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data; - data->state = 0; - data->textOrReceiveState = 0; - data->t0A = 0; - data->t0B = 0; - data->t0C = 0; - data->t0D = 0; - data->stateAdvanceDelay = 0; - data->t02 = 0; - data->t04 = 0; - data->t06 = 0; - data->initialSendResult = 0; - data->t10 = AllocZeroed(sizeof(struct MEvent_Str_2)); -} - -static void ResetDelayTimer(u16 *a0) -{ - *a0 = 0; -} - -static bool32 AdvanceDelayTimerCheckTimeout(u16 * a0, u16 a1) -{ - if (++(*a0) > a1) - { - *a0 = 0; - return TRUE; - } - return FALSE; -} - -static void Task_EReaderComm(u8 taskId) -{ - struct MEventTaskData1 *data = (struct MEventTaskData1 *)gTasks[taskId].data; - switch (data->state) - { - case 0: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_ReceiveMysteryGiftWithEReader)) - data->state = 1; - break; - case 1: - ResetTTDataBuffer(); - ResetDelayTimer(&data->stateAdvanceDelay); - data->state = 2; - break; - case 2: - if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10)) - data->state = 3; - break; - case 3: - if (!IsEReaderConnectionSane()) - { - CloseLink(); - data->state = 4; - } - else - data->state = 13; - break; - case 4: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_SelectConnectFromEReaderMenu)) - { - AddTextPrinterToWindow1(gJPText_SelectConnectWithGBA); - ResetDelayTimer(&data->stateAdvanceDelay); - data->state = 5; - } - break; - case 5: - if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 90)) - { - ResetTTDataBuffer(); - data->state = 6; - } - else if (JOY_NEW(B_BUTTON)) - { - ResetDelayTimer(&data->stateAdvanceDelay); - PlaySE(SE_SELECT); - data->state = 23; - } - break; - case 6: - if (JOY_NEW(B_BUTTON)) - { - PlaySE(SE_SELECT); - CloseLink(); - ResetDelayTimer(&data->stateAdvanceDelay); - data->state = 23; - } - else if (GetLinkPlayerCount_2() > 1) - { - ResetDelayTimer(&data->stateAdvanceDelay); - CloseLink(); - data->state = 7; - } - else if (sub_81436EC()) - { - PlaySE(SE_SELECT); - CloseLink(); - ResetDelayTimer(&data->stateAdvanceDelay); - data->state = 8; - } - else if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 10)) - { - CloseLink(); - ResetTTDataBuffer(); - ResetDelayTimer(&data->stateAdvanceDelay); - } - break; - case 7: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_LinkIsIncorrect)) - data->state = 4; - break; - case 8: - AddTextPrinterToWindow1(gJPText_Connecting); - SendUnknownSerialData_Init(&sMEventSendToEReaderManager, gMultiBootProgram_EReader_End - gMultiBootProgram_EReader_Start, gMultiBootProgram_EReader_Start); - data->state = 9; - break; - case 9: - data->initialSendResult = SendUnknownSerialData_Run(&sMEventSendToEReaderManager); - if (data->initialSendResult != 0) - data->state = 10; - break; - case 10: - SendUnknownSerialData_Teardown(&sMEventSendToEReaderManager); - if (data->initialSendResult == 3) - // Error - data->state = 20; - else if (data->initialSendResult == 1) - { - // OK - ResetDelayTimer(&data->stateAdvanceDelay); - AddTextPrinterToWindow1(gJPText_PleaseWaitAMoment); - data->state = 11; - } - else - // Try again - data->state = 0; - break; - case 11: - if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 840)) - data->state = 12; - break; - case 12: - ResetTTDataBuffer(); - AddTextPrinterToWindow1(gJPText_AllowEReaderToLoadCard); - data->state = 13; - break; - case 13: - switch (EReaderReceive(&data->textOrReceiveState, &data->stateAdvanceDelay)) - { - case 0: - // Running - break; - case 2: - // Done - AddTextPrinterToWindow1(gJPText_Connecting); - data->state = 14; - break; - case 1: - // Cancelled - PlaySE(SE_SELECT); - CloseLink(); - data->state = 23; - break; - case 5: - // Error Try Again - CloseLink(); - data->state = 21; - break; - case 3: - case 4: - // Error CheckLink - CloseLink(); - data->state = 20; - break; - } - break; - case 14: - if (HasLinkErrorOccurred()) - { - CloseLink(); - data->state = 20; - } - else if (GetBlockReceivedStatus()) - { - ResetBlockReceivedFlags(); - data->state = 15; - } - break; - case 15: - data->initialSendResult = ValidateTrainerTowerData((struct EReaderTrainerTowerSet *)gDecompressionBuffer); - SetCloseLinkCallbackAndType(data->initialSendResult); - data->state = 16; - break; - case 16: - if (!gReceivedRemoteLinkPlayers) - { - if (data->initialSendResult == 1) - data->state = 17; - else - data->state = 20; - } - break; - case 17: - if (CEReaderTool_SaveTrainerTower((struct EReaderTrainerTowerSet *)gDecompressionBuffer)) - { - AddTextPrinterToWindow1(gJPText_ConnectionComplete); - ResetDelayTimer(&data->stateAdvanceDelay); - data->state = 18; - } - else - data->state = 22; - break; - case 18: - if (AdvanceDelayTimerCheckTimeout(&data->stateAdvanceDelay, 120)) - { - AddTextPrinterToWindow1(gJPText_NewTrainerHasComeToSevii); - PlayFanfare(MUS_OBTAIN_ITEM); - data->state = 19; - } - break; - case 19: - if (IsFanfareTaskInactive() && JOY_NEW(A_BUTTON | B_BUTTON)) - data->state = 26; - break; - case 23: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_CardReadingHasBeenHalted)) - data->state = 26; - break; - case 20: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_ConnectionErrorCheckLink)) - data->state = 0; - break; - case 21: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_ConnectionErrorTryAgain)) - data->state = 0; - break; - case 22: - if (PrintMysteryGiftMenuMessage(&data->textOrReceiveState, gJPText_WriteErrorUnableToSaveData)) - data->state = 0; - break; - case 26: - HelpSystem_Enable(); - Free(data->t10); - DestroyTask(taskId); - SetMainCallback2(MainCB_FreeAllBuffersAndReturnToInitTitleScreen); - break; - } -} - -void InitMEventData(void) -{ - CpuFill32(0, &gSaveBlock1Ptr->mysteryGift, sizeof(gSaveBlock1Ptr->mysteryGift)); - BlankMENewsJisan(); - EC_ResetMEventProfileMaybe(); -} - -struct WonderNews * GetSavedWonderNews(void) -{ - return &gSaveBlock1Ptr->mysteryGift.news; -} - -struct WonderCard * GetSavedWonderCard(void) -{ - return &gSaveBlock1Ptr->mysteryGift.card; -} - -struct WonderCardMetadata * sav1_get_mevent_buffer_2(void) -{ - return &gSaveBlock1Ptr->mysteryGift.cardMetadata; -} - -struct WonderNewsMetadata * GetMENewsJisanStructPtr(void) -{ - return &gSaveBlock1Ptr->mysteryGift.newsMetadata; -} - -u16 * GetMEventProfileECWordsMaybe(void) -{ - return gSaveBlock1Ptr->mysteryGift.questionnaireWords; -} - -void DestroyWonderNews(void) -{ - BlankWonderNews(); -} - -bool32 OverwriteSavedWonderNewsWithReceivedNews(const struct WonderNews * src) -{ - if (!IsReceivedWonderNewsHeaderValid(src)) - return FALSE; - BlankWonderNews(); - gSaveBlock1Ptr->mysteryGift.news = *src; - gSaveBlock1Ptr->mysteryGift.newsCrc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryGift.news, sizeof(struct WonderNews)); - return TRUE; -} - -bool32 ValidateReceivedWonderNews(void) -{ - if (CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryGift.news, sizeof(struct WonderNews)) != gSaveBlock1Ptr->mysteryGift.newsCrc) - return FALSE; - if (!IsReceivedWonderNewsHeaderValid(&gSaveBlock1Ptr->mysteryGift.news)) - return FALSE; - return TRUE; -} - -static bool32 IsReceivedWonderNewsHeaderValid(const struct WonderNews * data) -{ - if (data->newsId == 0) - return FALSE; - return TRUE; -} - -bool32 WonderNews_Test_Unk_02(void) -{ - const struct WonderNews * data = &gSaveBlock1Ptr->mysteryGift.news; - if (data->sendType == 0) - return FALSE; - return TRUE; -} - -static void BlankWonderNews(void) -{ - CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->mysteryGift.news)); - gSaveBlock1Ptr->mysteryGift.newsCrc = 0; -} - -static void BlankMENewsJisan(void) -{ - CpuFill32(0, GetMENewsJisanStructPtr(), sizeof(struct WonderNewsMetadata)); - MENewsJisanReset(); -} - -bool32 MEvent_HaveAlreadyReceivedWonderNews(const u8 * src) -{ - const u8 * r5 = (const u8 *)&gSaveBlock1Ptr->mysteryGift.news; - u32 i; - if (!ValidateReceivedWonderNews()) - return FALSE; - for (i = 0; i < sizeof(struct WonderNews); i++) - { - if (r5[i] != src[i]) - return FALSE; - } - return TRUE; -} - -void DestroyWonderCard(void) -{ - BlankSavedWonderCard(); - BlankMEventBuffer2(); - BlankBuffer344(); - ClearRamScript(); - ResetMysteryEventFlags(); - ResetMysteryEventVars(); - ClearEReaderTrainer(&gSaveBlock2Ptr->battleTower.ereaderTrainer); -} - -bool32 OverwriteSavedWonderCardWithReceivedCard(const struct WonderCard * data) -{ - struct WonderCardMetadata * r2; - struct WonderCard * r1; - if (!IsReceivedWonderCardHeaderValid(data)) - return FALSE; - DestroyWonderCard(); - memcpy(&gSaveBlock1Ptr->mysteryGift.card, data, sizeof(struct WonderCard)); - gSaveBlock1Ptr->mysteryGift.cardCrc = CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryGift.card, sizeof(struct WonderCard)); - // Annoying hack to match - r2 = &gSaveBlock1Ptr->mysteryGift.cardMetadata; - r1 = &gSaveBlock1Ptr->mysteryGift.card; - r2->iconSpecies = r1->iconSpecies; - return TRUE; -} - -bool32 ValidateReceivedWonderCard(void) -{ - if (gSaveBlock1Ptr->mysteryGift.cardCrc != CalcCRC16WithTable((void *)&gSaveBlock1Ptr->mysteryGift.card, sizeof(struct WonderCard))) - return FALSE; - if (!IsReceivedWonderCardHeaderValid(&gSaveBlock1Ptr->mysteryGift.card)) - return FALSE; - if (!ValidateRamScript()) - return FALSE; - return TRUE; -} - -static bool32 IsReceivedWonderCardHeaderValid(const struct WonderCard * data) -{ - if (data->flagId == 0) - return FALSE; - if (data->type > 2) - return FALSE; - if (!(data->sendType == 0 || data->sendType == 1 || data->sendType == 2)) - return FALSE; - if (data->bgType > 7) - return FALSE; - if (data->maxStamps > 7) - return FALSE; - return TRUE; -} - -bool32 WonderCard_Test_Unk_08_6(void) -{ - const struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->sendType == 0) - return FALSE; - return TRUE; -} - -static void BlankSavedWonderCard(void) -{ - CpuFill32(0, &gSaveBlock1Ptr->mysteryGift.card, sizeof(struct WonderCard)); - gSaveBlock1Ptr->mysteryGift.cardCrc = 0; -} - -static void BlankMEventBuffer2(void) -{ - CpuFill32(0, sav1_get_mevent_buffer_2(), 18 * sizeof(u16)); - gSaveBlock1Ptr->mysteryGift.cardMetadataCrc = 0; -} - -u16 GetWonderCardFlagId(void) -{ - if (ValidateReceivedWonderCard()) - return gSaveBlock1Ptr->mysteryGift.card.flagId; - return 0; -} - -void MEvent_WonderCardResetUnk08_6(struct WonderCard * buffer) -{ - if (buffer->sendType == 1) - buffer->sendType = 0; -} - -static bool32 IsCardIdInValidRange(u16 a0) -{ - if (a0 >= 1000 && a0 < 1020) - return TRUE; - return FALSE; -} - -bool32 CheckReceivedGiftFromWonderCard(void) -{ - u16 value = GetWonderCardFlagId(); - if (!IsCardIdInValidRange(value)) - return FALSE; - if (FlagGet(sGiftItemFlagIds[value - 1000]) == TRUE) - return FALSE; - return TRUE; -} - -static s32 CountReceivedDistributionMons(const struct WonderCardMetadata * data, s32 size) -{ - s32 r3 = 0; - s32 i; - for (i = 0; i < size; i++) - { - if (data->stampData[1][i] && data->stampData[0][i]) - r3++; - } - return r3; -} - -static bool32 HasPlayerAlreadyReceivedDistributedMon(const struct WonderCardMetadata * data1, const u16 * data2, s32 size) -{ - s32 i; - for (i = 0; i < size; i++) - { - if (data1->stampData[1][i] == data2[1]) - return TRUE; - if (data1->stampData[0][i] == data2[0]) - return TRUE; - } - return FALSE; -} - -static bool32 IsWonderCardSpeciesValid(const u16 * data) -{ - if (data[1] == 0) - return FALSE; - if (data[0] == SPECIES_NONE) - return FALSE; - if (data[0] >= NUM_SPECIES) - return FALSE; - return TRUE; -} - -static s32 ValidateCardAndCountMonsReceived(void) -{ - struct WonderCard * data; - if (!ValidateReceivedWonderCard()) - return 0; - data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type != 1) - return 0; - return CountReceivedDistributionMons(&gSaveBlock1Ptr->mysteryGift.cardMetadata, data->maxStamps); -} - -bool32 MEvent_ReceiveDistributionMon(const u16 * data) -{ - struct WonderCard * buffer = &gSaveBlock1Ptr->mysteryGift.card; - s32 capacity = buffer->maxStamps; - s32 i; - if (!IsWonderCardSpeciesValid(data)) - return FALSE; - if (HasPlayerAlreadyReceivedDistributedMon(&gSaveBlock1Ptr->mysteryGift.cardMetadata, data, capacity)) - return FALSE; - for (i = 0; i < capacity; i++) - { - if (gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[1][i] == 0 && gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[0][i] == 0) - { - gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[1][i] = data[1]; - gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[0][i] = data[0]; - return TRUE; - } - } - return FALSE; -} - -#if defined(FIRERED) -#define MEVENT_HEADER_VERSION_CODE 1 -#elif defined(LEAFGREEN) -#define MEVENT_HEADER_VERSION_CODE 2 -#endif - -void BuildMEventClientHeader(struct MEventClientHeaderStruct * data) -{ - s32 i; - CpuFill32(0, data, sizeof(struct MEventClientHeaderStruct)); - // Magic - data->unk_00 = 0x101; - data->unk_04 = 1; - data->unk_08 = 1; - data->unk_0C = 1; - data->unk_10 = MEVENT_HEADER_VERSION_CODE; - - // Check whether a card already exists - if (ValidateReceivedWonderCard()) - { - // Populate fields - data->id = GetSavedWonderCard()->flagId; - data->unk_20 = *sav1_get_mevent_buffer_2(); - data->maxDistributionMons = GetSavedWonderCard()->maxStamps; - } - else - data->id = 0; - - // Get something - for (i = 0; i < 4; i++) - data->unk_16[i] = gSaveBlock1Ptr->mysteryGift.questionnaireWords[i]; - - // Get player ID - CopyTrainerId(data->playerTrainerId, gSaveBlock2Ptr->playerTrainerId); - StringCopy(data->playerName, gSaveBlock2Ptr->playerName); - for (i = 0; i < 6; i++) - data->easyChatProfile[i] = gSaveBlock1Ptr->easyChatProfile[i]; - memcpy(data->gameCode, RomHeaderGameCode, 4); - data->version = RomHeaderSoftwareVersion; -} - -bool32 ValidateMEventClientHeader(const struct MEventClientHeaderStruct * data) -{ - if (data->unk_00 != 0x101) - return FALSE; - if (!(data->unk_04 & 1)) - return FALSE; - if (!(data->unk_08 & 1)) - return FALSE; - if (!(data->unk_0C & 1)) - return FALSE; - if (!(data->unk_10 & 0x0F)) - return FALSE; - return TRUE; -} - -u32 sub_8144418(const u16 * a0, const struct MEventClientHeaderStruct * a1, void *unused) -{ - if (a1->id == 0) - return 0; - if (*a0 == a1->id) - return 1; - return 2; -} - -u32 MEvent_CanPlayerReceiveDistributionMon(const u16 * a0, const struct MEventClientHeaderStruct * a1, void *unused) -{ - s32 numSpaces = a1->maxDistributionMons - CountReceivedDistributionMons(&a1->unk_20, a1->maxDistributionMons); - if (numSpaces == 0) - return 1; - if (HasPlayerAlreadyReceivedDistributedMon(&a1->unk_20, a0, a1->maxDistributionMons)) - return 3; - if (numSpaces == 1) - return 4; - return 2; -} - -bool32 sub_8144474(const struct MEventClientHeaderStruct * a0, const u16 * a1) -{ - s32 i; - for (i = 0; i < 4; i++) - { - if (a0->unk_16[i] != a1[i]) - return FALSE; - } - return TRUE; -} - -static s32 GetNumReceivedDistributionMons(const struct MEventClientHeaderStruct * a0) -{ - return CountReceivedDistributionMons(&a0->unk_20, a0->maxDistributionMons); -} - -u16 sub_81444B0(const struct MEventClientHeaderStruct * a0, u32 command) -{ - switch (command) - { - case 0: - return a0->unk_20.battlesWon; - case 1: - return a0->unk_20.battlesLost; - case 2: - return a0->unk_20.numTrades; - case 3: - return GetNumReceivedDistributionMons(a0); - case 4: - return a0->maxDistributionMons; - default: - AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 825); - return 0; - } -} - -// Increments an interaction count in the save block -static void IncrementBattleCardCount(u32 command) -{ - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 2) - { - u16 * dest = NULL; - switch (command) - { - case 0: - dest = &gSaveBlock1Ptr->mysteryGift.cardMetadata.battlesWon; - break; - case 1: - dest = &gSaveBlock1Ptr->mysteryGift.cardMetadata.battlesLost; - break; - case 2: - dest = &gSaveBlock1Ptr->mysteryGift.cardMetadata.numTrades; - break; - case 3: - break; - case 4: - break; - } - if (dest == NULL) - { - AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 868); - } - else if (++(*dest) > 999) - { - *dest = 999; - } - } -} - -u16 MEvent_GetBattleCardCount(u32 command) -{ - switch (command) - { - case 0: - { - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 2) - { - struct WonderCardMetadata * buffer = &gSaveBlock1Ptr->mysteryGift.cardMetadata; - return buffer->battlesWon; - } - break; - } - case 1: - { - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 2) - { - struct WonderCardMetadata * buffer = &gSaveBlock1Ptr->mysteryGift.cardMetadata; - return buffer->battlesLost; - } - break; - } - case 2: - { - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 2) - { - struct WonderCardMetadata * buffer = &gSaveBlock1Ptr->mysteryGift.cardMetadata; - return buffer->numTrades; - } - break; - } - case 3: - { - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 1) - return ValidateCardAndCountMonsReceived(); - break; - } - case 4: - { - struct WonderCard * data = &gSaveBlock1Ptr->mysteryGift.card; - if (data->type == 1) - return data->maxStamps; - break; - } - } - AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 913); - return 0; -} - -void MysteryGift_DisableStats(void) -{ - sReceivedWonderCardIsValid = FALSE; -} - -bool32 MysteryGift_TryEnableStatsByFlagId(u16 flagId) -{ - sReceivedWonderCardIsValid = FALSE; - if (flagId == 0) - return FALSE; - if (!ValidateReceivedWonderCard()) - return FALSE; - if (gSaveBlock1Ptr->mysteryGift.card.flagId != flagId) - return FALSE; - sReceivedWonderCardIsValid = TRUE; - return TRUE; -} - -void MysteryGift_TryIncrementStat(u32 eventId, u32 trainerId) -{ - if (sReceivedWonderCardIsValid) - { - switch (eventId) - { - case 2: // trade - RecordIdOfWonderCardSender(2, trainerId, gSaveBlock1Ptr->mysteryGift.trainerIds[1], 5); - break; - case 0: // link win - RecordIdOfWonderCardSender(0, trainerId, gSaveBlock1Ptr->mysteryGift.trainerIds[0], 5); - break; - case 1: // link loss - RecordIdOfWonderCardSender(1, trainerId, gSaveBlock1Ptr->mysteryGift.trainerIds[0], 5); - break; - default: - AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 988); - } - } -} - -static void BlankBuffer344(void) -{ - CpuFill32(0, gSaveBlock1Ptr->mysteryGift.trainerIds, sizeof(gSaveBlock1Ptr->mysteryGift.trainerIds)); -} - -// Looks up trainerId in an array idsList with count elements. -// If trainerId is found, rearranges idsList to put it in the front. -// Otherwise, drops the last element of the list and inserts -// trainerId at the front. -// Returns TRUE in the latter case. -static bool32 PlaceTrainerIdAtFrontOfList(u32 trainerId, u32 * idsList, s32 count) -{ - s32 i; - s32 j; - - for (i = 0; i < count; i++) - { - if (idsList[i] == trainerId) - break; - } - if (i == count) - { - for (j = count - 1; j > 0; j--) - { - idsList[j] = idsList[j - 1]; - } - idsList[0] = trainerId; - return TRUE; - } - else - { - for (j = i; j > 0; j--) - { - idsList[j] = idsList[j - 1]; - } - idsList[0] = trainerId; - return FALSE; - } -} - -static void RecordIdOfWonderCardSender(u32 eventId, u32 trainerId, u32 * idsList, s32 count) -{ - if (PlaceTrainerIdAtFrontOfList(trainerId, idsList, count)) - IncrementBattleCardCount(eventId); -} diff --git a/src/mevent_client.c b/src/mevent_client.c deleted file mode 100644 index e2d226ed6..000000000 --- a/src/mevent_client.c +++ /dev/null @@ -1,290 +0,0 @@ -#include "global.h" -#include "gflib.h" -#include "decompress.h" -#include "overworld.h" -#include "script.h" -#include "battle_tower.h" -#include "mystery_event_script.h" -#include "mevent.h" -#include "mevent_server.h" - -static EWRAM_DATA struct mevent_client * s_mevent_client_ptr = NULL; - -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 *); - -extern const struct mevent_client_cmd gMEventClientScript_InitialListen[]; - -void mevent_client_do_init(void) -{ - s_mevent_client_ptr = AllocZeroed(sizeof(struct mevent_client)); - mevent_client_init(s_mevent_client_ptr, 1, 0); -} - -u32 mevent_client_do_exec(u16 * a0) -{ - u32 result; - if (s_mevent_client_ptr == NULL) - return 6; - result = mevent_client_exec(s_mevent_client_ptr); - if (result == 6) - { - *a0 = s_mevent_client_ptr->param; - mevent_client_free_resources(s_mevent_client_ptr); - Free(s_mevent_client_ptr); - s_mevent_client_ptr = NULL; - } - return result; -} - -void mevent_client_inc_flag(void) -{ - s_mevent_client_ptr->flag++; -} - -void *mevent_client_get_buffer(void) -{ - return s_mevent_client_ptr->buffer; -} - -void mevent_client_set_param(u32 a0) -{ - s_mevent_client_ptr->param = a0; -} - -static void mevent_client_init(struct mevent_client * svr, 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); -} - -static void mevent_client_free_resources(struct mevent_client * svr) -{ - Free(svr->sendBuffer); - Free(svr->recvBuffer); - Free(svr->cmdBuffer); - Free(svr->buffer); -} - -static void mevent_client_jmp_buffer(struct mevent_client * svr) -{ - memcpy(svr->cmdBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE); - svr->cmdidx = 0; -} - -static void mevent_client_send_word(struct mevent_client * svr, 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)); -} - -static u32 client_mainseq_0(struct mevent_client * svr) -{ - // init - memcpy(svr->cmdBuffer, gMEventClientScript_InitialListen, ME_SEND_BUF_SIZE); - svr->cmdidx = 0; - svr->mainseqno = 4; - svr->flag = 0; - return 0; -} - -static u32 client_mainseq_1(struct mevent_client * svr) -{ - // done - return 6; -} - -static u32 client_mainseq_2(struct mevent_client * svr) -{ - // do recv - if (mevent_srv_sub_recv(&svr->manager)) - { - svr->mainseqno = 4; - svr->flag = 0; - } - return 1; -} - -static u32 client_mainseq_3(struct mevent_client * svr) -{ - // do send - if (mevent_srv_sub_send(&svr->manager)) - { - svr->mainseqno = 4; - svr->flag = 0; - } - return 1; -} - -static u32 client_mainseq_4(struct mevent_client * svr) -{ - // process command - struct mevent_client_cmd * cmd = &svr->cmdBuffer[svr->cmdidx]; - ++svr->cmdidx; - switch (cmd->instr) - { - case 0: - break; - case 1: - svr->param = cmd->parameter; - svr->mainseqno = 1; - svr->flag = 0; - break; - case 2: - mevent_srv_sub_init_recv(&svr->manager, cmd->parameter, svr->recvBuffer); - svr->mainseqno = 2; - svr->flag = 0; - break; - case 3: - svr->mainseqno = 3; - svr->flag = 0; - break; - case 20: - mevent_srv_sub_init_send(&svr->manager, 0x14, svr->sendBuffer, 0); - svr->mainseqno = 3; - svr->flag = 0; - break; - case 19: - mevent_client_send_word(svr, 0x12, GetGameStat(cmd->parameter)); - svr->mainseqno = 3; - svr->flag = 0; - break; - case 6: - if (svr->param == 0) - mevent_client_jmp_buffer(svr); - break; - case 7: - if (svr->param == 1) - mevent_client_jmp_buffer(svr); - break; - case 4: - mevent_client_jmp_buffer(svr); - 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: - BuildMEventClientHeader(svr->sendBuffer); - mevent_srv_sub_init_send(&svr->manager, 0x11, svr->sendBuffer, sizeof(struct MEventClientHeaderStruct)); - break; - case 14: - mevent_client_send_word(svr, 0x13, svr->param); - break; - case 10: - OverwriteSavedWonderCardWithReceivedCard(svr->recvBuffer); - break; - case 9: - if (!MEvent_HaveAlreadyReceivedWonderNews(svr->recvBuffer)) - { - OverwriteSavedWonderNewsWithReceivedNews(svr->recvBuffer); - mevent_client_send_word(svr, 0x13, 0); - } - else - // Other trainer already has news - mevent_client_send_word(svr, 0x13, 1); - break; - case 15: - svr->mainseqno = 6; - svr->flag = 0; - break; - case 16: - MEvent_ReceiveDistributionMon(svr->recvBuffer); - break; - case 17: - InitRamScript_NoObjectEvent(svr->recvBuffer, 1000); - break; - case 18: - memcpy(&gSaveBlock2Ptr->battleTower.ereaderTrainer, svr->recvBuffer, sizeof(struct BattleTowerEReaderTrainer)); - ValidateEReaderTrainer(); - break; - case 21: - memcpy(gDecompressionBuffer, svr->recvBuffer, ME_SEND_BUF_SIZE); - svr->mainseqno = 7; - svr->flag = 0; - break; - } - - return 1; -} - -static u32 client_mainseq_5(struct mevent_client * svr) -{ - // wait flag - if (svr->flag) - { - svr->mainseqno = 4; - svr->flag = 0; - } - return 1; -} - -static u32 client_mainseq_6(struct mevent_client * svr) -{ - // Run mevent buffer script - switch (svr->flag) - { - case 0: - MEventScript_InitContext(svr->recvBuffer); - ++svr->flag; - break; - case 1: - if (!MEventScript_Run(&svr->param)) - { - svr->mainseqno = 4; - svr->flag = 0; - } - break; - } - return 1; -} - -static u32 client_mainseq_7(struct mevent_client * svr) -{ - // exec arbitrary code - u32 (*func)(u32 *, struct SaveBlock2 *, struct SaveBlock1 *) = (void *)gDecompressionBuffer; - if (func(&svr->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1) - { - svr->mainseqno = 4; - svr->flag = 0; - } - return 1; -} - -static u32 mevent_client_exec(struct mevent_client * svr) -{ - u32 (*funcs[])(struct mevent_client *) = { - client_mainseq_0, - client_mainseq_1, - client_mainseq_2, - client_mainseq_3, - client_mainseq_4, - client_mainseq_5, - client_mainseq_6, - client_mainseq_7 - }; - return funcs[svr->mainseqno](svr); -} diff --git a/src/mevent_scripts.c b/src/mevent_scripts.c deleted file mode 100644 index 0c2918655..000000000 --- a/src/mevent_scripts.c +++ /dev/null @@ -1,192 +0,0 @@ -#include "global.h" -#include "mevent_server.h" - -extern const struct mevent_server_cmd gServerScript_ClientCanceledCard[]; - -// Unreferenced -const u8 gUnknown_84687A0[] = _("You have collected all STAMPs!\nWant to input a CARD as a prize?"); - -/* CLIENT SCRIPTS */ - -const struct mevent_client_cmd gMEventClientScript_InitialListen[] = { // 84687E0 - CLI_RECEIVE(0x10), - CLI_JUMPBUF -}; - -const struct mevent_client_cmd gMEventClientScript_Send1442CC[] = { - CLI_SNDHEAD, - CLI_WAITSND, - CLI_RECEIVE(0x10), - CLI_JUMPBUF -}; - -const struct mevent_client_cmd gMEventClientScript_UnableToRecv[] = { // can't accept card or news - CLI_SENDALL, - CLI_RETURN(0x0a) -}; - -const struct mevent_client_cmd gMEventClientScript_CommError[] = { // comm error - CLI_SENDALL, - CLI_RETURN(0x0b) -}; - -const struct mevent_client_cmd gMEventClientScript_NothingSentOver[] = { // nothing sent - CLI_SENDALL, - CLI_RETURN(0x00) -}; - -const struct mevent_client_cmd gMEventClientScript_ReceiveCardAndReturnSuccess[] = { // card success - CLI_RECEIVE(0x16), - CLI_RECVSAV, - CLI_RECEIVE(0x19), - CLI_RECVRAM, - CLI_SENDALL, - CLI_RETURN(0x02) -}; - -const struct mevent_client_cmd gMEventClientScript_ReceiveNewsAndValidate[] = { - CLI_RECEIVE(0x17), - CLI_VLDNEWS, - CLI_WAITSND, - CLI_RECEIVE(0x10), - CLI_JUMPBUF -}; - -const struct mevent_client_cmd gMEventClientScript_AlreadyHadNews[] = { // already had news - CLI_SENDALL, - CLI_RETURN(0x07) -}; - -const struct mevent_client_cmd gMEventClientScript_RecvNewsSuccess[] = { // news success - CLI_SENDALL, - CLI_RETURN(0x03) -}; - -const struct mevent_client_cmd gMEventClientScript_AskWouldLikeToTossCard[] = { - CLI_REQWORD, - CLI_SNDWORD, - CLI_WAITSND, - CLI_RECEIVE(0x10), - CLI_JUMPBUF -}; - -const struct mevent_client_cmd gMEventClientScript_OtherTrainerCanceled[] = { // comm canceled - CLI_SENDALL, - CLI_RETURN(0x09) -}; - -const struct mevent_client_cmd gMEventClientScript_AlreadyHadCard[] = { // already had card - CLI_SENDALL, - CLI_RETURN(0x05) -}; - -const struct mevent_client_cmd gMEventClientScript_SuccessFromBuffer[] = { // success from buffer - CLI_RECEIVE(0x15), - CLI_RECVBUF, - CLI_SENDALL, - CLI_RETURN(0x0d) -}; - -/* SERVER SCRIPTS */ - -const struct mevent_server_cmd gMEventSrvScript_UnableToSend[] = { - SRV_SEND(0x10, gMEventClientScript_UnableToRecv), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x0a) -}; - -const struct mevent_server_cmd gUnknown_8468950[] = { - SRV_SEND(0x10, gMEventClientScript_CommError), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x0b) -}; - -const struct mevent_server_cmd gUnknown_8468980[] = { - SRV_SEND(0x10, gMEventClientScript_OtherTrainerCanceled), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x09) -}; - -const struct mevent_server_cmd gMEventSrvScript_OtherTrnHasNews[] = { - SRV_SEND(0x10, gMEventClientScript_AlreadyHadNews), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x07) -}; - -const struct mevent_server_cmd gMEventSrvScript_SentNewsSuccess[] = { - SRV_SEND(0x28, gMEventClientScript_ReceiveNewsAndValidate), - SRV_WAITSND, - SRV_SEND_NEWS, - SRV_WAITSND, - SRV_RECV(0x13), - SRV_READWORD, - SRV_BRANCHIF(0x01, gMEventSrvScript_OtherTrnHasNews), - SRV_SEND(0x10, gMEventClientScript_RecvNewsSuccess), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x03) -}; - -const struct mevent_server_cmd gMEventSrvScript_SendCardSuccess[] = { - SRV_SEND(0x30, gMEventClientScript_ReceiveCardAndReturnSuccess), - SRV_WAITSND, - SRV_SEND_CARD, - SRV_WAITSND, - SRV_BUFFER_SEND, - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x02) -}; - -const struct mevent_server_cmd gMEventSrvScript_AskClientToOverwriteCard[] = { - SRV_SEND(0x28, gMEventClientScript_AskWouldLikeToTossCard), - SRV_WAITSND, - SRV_RECV(0x13), - SRV_READWORD, - SRV_BRANCHIF(0x00, gMEventSrvScript_SendCardSuccess), - SRV_BRANCH(gServerScript_ClientCanceledCard) -}; - -const struct mevent_server_cmd gMEventSrvScript_OtherTrnHasCard[] = { - SRV_SEND(0x10, gMEventClientScript_AlreadyHadCard), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x05) -}; - -const struct mevent_server_cmd gUnknown_8468B3C[] = { - SRV_SEND(0x10, gMEventClientScript_NothingSentOver), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x00) -}; - -const struct mevent_server_cmd gMEventSrvScript_SendNews[] = { - SRV_BUFFER_NEWS, - SRV_SEND(0x20, gMEventClientScript_Send1442CC), - SRV_WAITSND, - SRV_RECV(0x11), - SRV_READ_1442CC, - SRV_VALID_1442CC, - SRV_BRANCHIF(0x00, gMEventSrvScript_UnableToSend), - SRV_BRANCH(gMEventSrvScript_SentNewsSuccess) -}; - -const struct mevent_server_cmd gMEventSrvScript_SendCard[] = { - SRV_BUFFER_CARD, - SRV_RAM_SCRIPT_IF_VALID, - SRV_SEND(0x20, gMEventClientScript_Send1442CC), - SRV_WAITSND, - SRV_RECV(0x11), - SRV_READ_1442CC, - SRV_VALID_1442CC, - SRV_BRANCHIF(0x00, gMEventSrvScript_UnableToSend), - SRV_CHECK_1442CC_14, - SRV_BRANCHIF(0x02, gMEventSrvScript_AskClientToOverwriteCard), - SRV_BRANCHIF(0x00, gMEventSrvScript_SendCardSuccess), - SRV_BRANCH(gMEventSrvScript_OtherTrnHasCard) -}; diff --git a/src/mevent_server.c b/src/mevent_server.c deleted file mode 100644 index 7d4929195..000000000 --- a/src/mevent_server.c +++ /dev/null @@ -1,279 +0,0 @@ -#include "global.h" -#include "gflib.h" -#include "script.h" -#include "mevent.h" -#include "mevent_server.h" - -EWRAM_DATA struct mevent_srv_common * s_mevent_srv_common_ptr = 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 *); - -extern const struct mevent_server_cmd gMEventSrvScript_SendNews[]; -extern const struct mevent_server_cmd gMEventSrvScript_SendCard[]; - -void mevent_srv_init_wnews(void) -{ - s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common)); - mevent_srv_init_common(s_mevent_srv_common_ptr, gMEventSrvScript_SendNews, 0, 1); -} - -void mevent_srv_new_wcard(void) -{ - s_mevent_srv_common_ptr = AllocZeroed(sizeof(struct mevent_srv_common)); - mevent_srv_init_common(s_mevent_srv_common_ptr, gMEventSrvScript_SendCard, 0, 1); -} - -u32 mevent_srv_common_do_exec(u16 * a0) -{ - u32 result; - if (s_mevent_srv_common_ptr == NULL) - return 3; - result = mevent_srv_exec_common(s_mevent_srv_common_ptr); - if (result == 3) - { - *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; - } - return result; -} - -static void mevent_srv_init_common(struct mevent_srv_common * svr, const void *cmdBuffer, u32 sendPlayerNo, u32 recvPlayerNo) -{ - svr->unk_00 = 0; - svr->mainseqno = 0; - svr->card = AllocZeroed(sizeof(struct WonderCard)); - svr->news = AllocZeroed(sizeof(struct WonderNews)); - svr->recvBuffer = AllocZeroed(ME_SEND_BUF_SIZE); - svr->mevent_unk1442cc = AllocZeroed(sizeof(struct MEventClientHeaderStruct)); - svr->cmdBuffer = cmdBuffer; - svr->cmdidx = 0; - mevent_srv_sub_init(&svr->manager, sendPlayerNo, recvPlayerNo); -} - -static void mevent_srv_free_resources(struct mevent_srv_common * svr) -{ - Free(svr->card); - Free(svr->news); - Free(svr->recvBuffer); - Free(svr->mevent_unk1442cc); -} - -static void mevent_srv_common_init_send(struct mevent_srv_common * svr, u32 ident, const void *src, u32 size) -{ - AGB_ASSERT_EX(size <= ME_SEND_BUF_SIZE, ABSPATH("mevent_server.c"), 257); - mevent_srv_sub_init_send(&svr->manager, ident, src, size); -} - -static void *mevent_first_if_not_null_else_second(void *a0, void *a1) -{ - if (a0 != NULL) - return a0; - else - return a1; -} - -static u32 mevent_compare_pointers(void *a0, void *a1) -{ - if (a1 < a0) - return 0; - else if (a1 == a0) - return 1; - else - return 2; -} - -static u32 common_mainseq_0(struct mevent_srv_common * svr) -{ - // start - svr->mainseqno = 4; - return 0; -} - -static u32 common_mainseq_1(struct mevent_srv_common * svr) -{ - // done - return 3; -} - -static u32 common_mainseq_2(struct mevent_srv_common * svr) -{ - // do recv - if (mevent_srv_sub_recv(&svr->manager)) - svr->mainseqno = 4; - return 1; -} - -static u32 common_mainseq_3(struct mevent_srv_common * svr) -{ - // do send - if (mevent_srv_sub_send(&svr->manager)) - svr->mainseqno = 4; - return 1; -} - -static u32 common_mainseq_4(struct mevent_srv_common * svr) -{ - // process command - const struct mevent_server_cmd * cmd = &svr->cmdBuffer[svr->cmdidx]; - void *ptr; - svr->cmdidx++; - - switch (cmd->instr) - { - case 0: - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 354); - svr->mainseqno = 1; - svr->param = cmd->flag; - break; - case 1: - svr->mainseqno = 3; - break; - case 2: - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 364); - mevent_srv_sub_init_recv(&svr->manager, cmd->flag, svr->recvBuffer); - svr->mainseqno = 2; - break; - case 3: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 370); - svr->cmdidx = 0; - svr->cmdBuffer = cmd->parameter; - break; - case 5: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 376); - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 377); - memcpy(svr->mevent_unk1442cc, svr->recvBuffer, sizeof(struct MEventClientHeaderStruct)); - break; - case 6: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 382); - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 383); - svr->param = ValidateMEventClientHeader(svr->mevent_unk1442cc); - break; - case 4: - if (svr->param == cmd->flag) - { - svr->cmdidx = 0; - svr->cmdBuffer = cmd->parameter; - } - break; - case 7: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 396); - ptr = mevent_first_if_not_null_else_second(cmd->parameter, svr->card); - svr->param = sub_8144418(ptr, svr->mevent_unk1442cc, ptr); - break; - case 8: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 402); - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 403); - svr->param = *(u32 *)svr->recvBuffer; - break; - case 9: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 408); - ptr = mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord); - svr->param = MEvent_CanPlayerReceiveDistributionMon(ptr, svr->mevent_unk1442cc, ptr); - break; - case 10: - AGB_ASSERT_EX(cmd->parameter == NULL, ABSPATH("mevent_server.c"), 415); - svr->param = sub_81444B0(svr->mevent_unk1442cc, cmd->flag); - break; - case 11: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 420); - svr->param = sub_8144474(svr->mevent_unk1442cc, cmd->parameter); - break; - case 12: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 426); - svr->param = mevent_compare_pointers(cmd->parameter, *(void **)svr->recvBuffer); - break; - case 14: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 432); - mevent_srv_common_init_send(svr, 0x17, mevent_first_if_not_null_else_second(cmd->parameter, svr->news), sizeof(struct WonderNews)); - break; - case 13: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 438); - mevent_srv_common_init_send(svr, 0x16, mevent_first_if_not_null_else_second(cmd->parameter, svr->card), sizeof(struct WonderCard)); - break; - case 16: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 444); - mevent_srv_common_init_send(svr, 0x18, mevent_first_if_not_null_else_second(cmd->parameter, &svr->sendWord), 4); - break; - case 15: - if (cmd->parameter == NULL) - mevent_srv_common_init_send(svr, 0x19, svr->sendBuffer1, svr->sendBuffer1Size); - else - mevent_srv_common_init_send(svr, 0x19, cmd->parameter, cmd->flag); - break; - case 18: - if (cmd->parameter == NULL) - mevent_srv_common_init_send(svr, 0x10, svr->sendBuffer2, svr->sendBuffer2Size); - else - mevent_srv_common_init_send(svr, 0x10, cmd->parameter, cmd->flag); - break; - case 19: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 466); - mevent_srv_common_init_send(svr, 0x1a, cmd->parameter, 188); - break; - case 20: - mevent_srv_common_init_send(svr, 0x15, cmd->parameter, cmd->flag); - break; - case 17: - mevent_srv_common_init_send(svr, 0x1c, cmd->parameter, cmd->flag); - break; - case 22: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 481); - memcpy(svr->card, cmd->parameter, 332); - break; - case 23: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 486); - memcpy(svr->news, cmd->parameter, 444); - break; - case 21: - AGB_ASSERT_EX(cmd->flag == FALSE, ABSPATH("mevent_server.c"), 491); - svr->sendWord = *(u32 *)cmd->parameter; - break; - case 24: - svr->sendBuffer1 = cmd->parameter; - svr->sendBuffer1Size = cmd->flag; - break; - case 25: - svr->sendBuffer2 = cmd->parameter; - svr->sendBuffer2Size = cmd->flag; - break; - case 26: - AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 506); - memcpy(svr->card, GetSavedWonderCard(), 332); - MEvent_WonderCardResetUnk08_6(svr->card); - break; - case 27: - AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 512); - memcpy(svr->news, GetSavedWonderNews(), 444); - break; - case 28: - AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, ABSPATH("mevent_server.c"), 517); - svr->sendBuffer1 = GetSavedRamScriptIfValid(); - break; - case 29: - mevent_srv_common_init_send(svr, 0x1b, cmd->parameter, cmd->flag); - break; - } - - return 1; -} - -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 mevent_srv_exec_common(struct mevent_srv_common * svr) -{ - u32 response; - AGB_ASSERT_EX(svr->mainseqno < NELEMS(func_tbl), ABSPATH("mevent_server.c"), 546); - response = func_tbl[svr->mainseqno](svr); - AGB_ASSERT_EX(svr->mainseqno < NELEMS(func_tbl), ABSPATH("mevent_server.c"), 548); - return response; -} diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c deleted file mode 100644 index 33148d539..000000000 --- a/src/mevent_server_helpers.c +++ /dev/null @@ -1,204 +0,0 @@ -#include "global.h" -#include "util.h" -#include "link.h" -#include "link_rfu.h" -#include "mevent_server.h" - -static u32 mevent_receive_func(struct mevent_srv_sub *); -static u32 mevent_send_func(struct mevent_srv_sub *); - -u32 mevent_srv_sub_recv(struct mevent_srv_sub * svr) -{ - return svr->recvFunc(svr); -} - -u32 mevent_srv_sub_send(struct mevent_srv_sub * svr) -{ - return svr->sendFunc(svr); -} - -void mevent_srv_sub_init(struct mevent_srv_sub * svr, u32 sendPlayerNo, u32 recvPlayerNo) -{ - svr->sendPlayerNo = sendPlayerNo; - svr->recvPlayerNo = recvPlayerNo; - svr->seqno = 0; - svr->sendCRC = 0; - svr->sendSize = 0; - svr->sendCounter = 0; - svr->recvCRC = 0; - svr->recvSize = 0; - svr->recvCounter = 0; - svr->sendBfr = NULL; - svr->recvBfr = NULL; - svr->sendFunc = mevent_send_func; - svr->recvFunc = mevent_receive_func; -} - -void mevent_srv_sub_init_send(struct mevent_srv_sub * svr, u32 ident, const void *src, u32 size) -{ - svr->seqno = 0; - svr->sendIdent = ident; - svr->sendCounter = 0; - svr->sendCRC = 0; - if (size != 0) - svr->sendSize = size; - else - svr->sendSize = ME_SEND_BUF_SIZE; - svr->sendBfr = src; -} - -void mevent_srv_sub_init_recv(struct mevent_srv_sub * svr, u32 ident, void *dest) -{ - svr->seqno = 0; - svr->recvIdent = ident; - svr->recvCounter = 0; - svr->recvCRC = 0; - svr->recvSize = 0; - svr->recvBfr = dest; -} - -static void mevent_recv_block(u32 recv_idx, void *dest, size_t size) -{ - memcpy(dest, gBlockRecvBuffer[recv_idx], size); -} - -static bool32 mevent_has_received(u32 recv_idx) -{ - if ((GetBlockReceivedStatus() >> recv_idx) & 1) - return TRUE; - else - return FALSE; -} - -static void mevent_reset_recv(u32 recv_idx) -{ - ResetBlockReceivedFlag(recv_idx); -} - -static bool32 mevent_receive_func(struct mevent_srv_sub * svr) -{ - struct send_recv_header header; - - switch (svr->seqno) - { - case 0: - if (mevent_has_received(svr->recvPlayerNo)) - { - mevent_recv_block(svr->recvPlayerNo, &header, sizeof(header)); - svr->recvSize = header.size; - svr->recvCRC = header.crc; - if (svr->recvSize > ME_SEND_BUF_SIZE) - { - LinkRfu_FatalError(); - return FALSE; - } - else if (svr->recvIdent != header.ident) - { - LinkRfu_FatalError(); - return FALSE; - } - else - { - svr->recvCounter = 0; - mevent_reset_recv(svr->recvPlayerNo); - ++svr->seqno; - } - } - break; - case 1: - if (mevent_has_received(svr->recvPlayerNo)) - { - size_t blocksiz = svr->recvCounter * 252; - if (svr->recvSize - blocksiz <= 252) - { - mevent_recv_block(svr->recvPlayerNo, svr->recvBfr + blocksiz, svr->recvSize - blocksiz); - ++svr->recvCounter; - ++svr->seqno; - } - else - { - mevent_recv_block(svr->recvPlayerNo, svr->recvBfr + blocksiz, 252); - ++svr->recvCounter; - } - mevent_reset_recv(svr->recvPlayerNo); - } - break; - case 2: - if (CalcCRC16WithTable(svr->recvBfr, svr->recvSize) != svr->recvCRC) - { - LinkRfu_FatalError(); - return FALSE; - } - else - { - svr->seqno = 0; - return TRUE; - } - break; - - } - - return FALSE; -} - -static bool32 mevent_send_func(struct mevent_srv_sub * svr) -{ - struct send_recv_header header; - - switch (svr->seqno) - { - case 0: - if (IsLinkTaskFinished()) - { - header.ident = svr->sendIdent; - header.size = svr->sendSize; - header.crc = CalcCRC16WithTable(svr->sendBfr, svr->sendSize); - svr->sendCRC = header.crc; - svr->sendCounter = 0; - SendBlock(0, &header, sizeof(header)); - ++svr->seqno; - } - break; - case 1: - if (IsLinkTaskFinished()) - { - if (mevent_has_received(svr->sendPlayerNo)) - { - size_t blocksiz; - mevent_reset_recv(svr->sendPlayerNo); - blocksiz = 252 * svr->sendCounter; - if (svr->sendSize - blocksiz <= 252) - { - SendBlock(0, svr->sendBfr + blocksiz, svr->sendSize - blocksiz); - ++svr->sendCounter; - ++svr->seqno; - } - else - { - SendBlock(0, svr->sendBfr + blocksiz, 252); - ++svr->sendCounter; - } - } - } - break; - case 2: - if (IsLinkTaskFinished()) - { - if (CalcCRC16WithTable(svr->sendBfr, svr->sendSize) != svr->sendCRC) - LinkRfu_FatalError(); - else - ++svr->seqno; - } - break; - case 3: - if (mevent_has_received(svr->sendPlayerNo)) - { - mevent_reset_recv(svr->sendPlayerNo); - svr->seqno = 0; - return TRUE; - } - break; - } - - return FALSE; -} diff --git a/src/mystery_gift.c b/src/mystery_gift.c new file mode 100644 index 000000000..b02d949f2 --- /dev/null +++ b/src/mystery_gift.c @@ -0,0 +1,634 @@ +#include "global.h" +#include "gflib.h" +#include "constants/songs.h" +#include "easy_chat.h" +#include "task.h" +#include "link.h" +#include "link_rfu.h" +#include "util.h" +#include "script.h" +#include "event_data.h" +#include "battle_tower.h" +#include "new_game.h" +#include "wonder_news.h" +#include "mystery_gift_menu.h" +#include "help_system.h" +#include "mystery_gift.h" +#include "strings.h" + +#define CALC_CRC(data) CalcCRC16WithTable((void *)&(data), sizeof(data)) + +static bool32 ValidateWonderNews(const struct WonderNews * src); +static void ClearSavedWonderNews(void); +static void ClearSavedWonderNewsMetadata(void); +static bool32 ValidateWonderCard(const struct WonderCard * src); +static void ClearSavedWonderCard(void); +static void ClearSavedWonderCardMetadata(void); +static void IncrementCardStatForNewTrainer(u32 eventId, u32 trainerId, u32 *idsList, s32 count); +static void ClearSavedTrainerIds(void); + +static const u16 sReceivedGiftFlags[] = { + FLAG_RECEIVED_AURORA_TICKET, + FLAG_RECEIVED_MYSTIC_TICKET, + FLAG_RECEIVED_OLD_SEA_MAP, // Not used until Emerald + FLAG_WONDER_CARD_UNUSED_1, + FLAG_WONDER_CARD_UNUSED_2, + FLAG_WONDER_CARD_UNUSED_3, + FLAG_WONDER_CARD_UNUSED_4, + FLAG_WONDER_CARD_UNUSED_5, + FLAG_WONDER_CARD_UNUSED_6, + FLAG_WONDER_CARD_UNUSED_7, + FLAG_WONDER_CARD_UNUSED_8, + FLAG_WONDER_CARD_UNUSED_9, + FLAG_WONDER_CARD_UNUSED_10, + FLAG_WONDER_CARD_UNUSED_11, + FLAG_WONDER_CARD_UNUSED_12, + FLAG_WONDER_CARD_UNUSED_13, + FLAG_WONDER_CARD_UNUSED_14, + FLAG_WONDER_CARD_UNUSED_15, + FLAG_WONDER_CARD_UNUSED_16, + FLAG_WONDER_CARD_UNUSED_17 +}; + +static EWRAM_DATA bool32 sStatsEnabled = FALSE; + +void ClearMysteryGift(void) +{ + CpuFill32(0, &gSaveBlock1Ptr->mysteryGift, sizeof(gSaveBlock1Ptr->mysteryGift)); + ClearSavedWonderNewsMetadata(); + InitQuestionnaireWords(); +} + +struct WonderNews * GetSavedWonderNews(void) +{ + return &gSaveBlock1Ptr->mysteryGift.news; +} + +struct WonderCard * GetSavedWonderCard(void) +{ + return &gSaveBlock1Ptr->mysteryGift.card; +} + +struct WonderCardMetadata * GetSavedWonderCardMetadata(void) +{ + return &gSaveBlock1Ptr->mysteryGift.cardMetadata; +} + +struct WonderNewsMetadata * GetSavedWonderNewsMetadata(void) +{ + return &gSaveBlock1Ptr->mysteryGift.newsMetadata; +} + +u16 * GetQuestionnaireWordsPtr(void) +{ + return gSaveBlock1Ptr->mysteryGift.questionnaireWords; +} + +// Equivalent to ClearSavedWonderCardAndRelated, but nothing else to clear +void ClearSavedWonderNewsAndRelated(void) +{ + ClearSavedWonderNews(); +} + +bool32 SaveWonderNews(const struct WonderNews * news) +{ + if (!ValidateWonderNews(news)) + return FALSE; + + ClearSavedWonderNews(); + gSaveBlock1Ptr->mysteryGift.news = *news; + gSaveBlock1Ptr->mysteryGift.newsCrc = CALC_CRC(gSaveBlock1Ptr->mysteryGift.news); + return TRUE; +} + +bool32 ValidateSavedWonderNews(void) +{ + if (CALC_CRC(gSaveBlock1Ptr->mysteryGift.news) != gSaveBlock1Ptr->mysteryGift.newsCrc) + return FALSE; + if (!ValidateWonderNews(&gSaveBlock1Ptr->mysteryGift.news)) + return FALSE; + return TRUE; +} + +static bool32 ValidateWonderNews(const struct WonderNews * news) +{ + if (news->id == 0) + return FALSE; + return TRUE; +} + +bool32 IsSendingSavedWonderNewsAllowed(void) +{ + const struct WonderNews * news = &gSaveBlock1Ptr->mysteryGift.news; + if (news->sendType == SEND_TYPE_DISALLOWED) + return FALSE; + return TRUE; +} + +static void ClearSavedWonderNews(void) +{ + CpuFill32(0, GetSavedWonderNews(), sizeof(gSaveBlock1Ptr->mysteryGift.news)); + gSaveBlock1Ptr->mysteryGift.newsCrc = 0; +} + +static void ClearSavedWonderNewsMetadata(void) +{ + CpuFill32(0, GetSavedWonderNewsMetadata(), sizeof(gSaveBlock1Ptr->mysteryGift.newsMetadata)); + WonderNews_Reset(); +} + +bool32 IsWonderNewsSameAsSaved(const u8 * news) +{ + const u8 * savedNews = (const u8 *)&gSaveBlock1Ptr->mysteryGift.news; + u32 i; + if (!ValidateSavedWonderNews()) + return FALSE; + + for (i = 0; i < sizeof(gSaveBlock1Ptr->mysteryGift.news); i++) + { + if (savedNews[i] != news[i]) + return FALSE; + } + return TRUE; +} + +void ClearSavedWonderCardAndRelated(void) +{ + ClearSavedWonderCard(); + ClearSavedWonderCardMetadata(); + ClearSavedTrainerIds(); + ClearRamScript(); + ClearMysteryGiftFlags(); + ClearMysteryGiftVars(); + ClearEReaderTrainer(&gSaveBlock2Ptr->battleTower.ereaderTrainer); +} + +bool32 SaveWonderCard(const struct WonderCard * card) +{ + struct WonderCardMetadata * metadata; + if (!ValidateWonderCard(card)) + return FALSE; + + ClearSavedWonderCardAndRelated(); + memcpy(&gSaveBlock1Ptr->mysteryGift.card, card, sizeof(struct WonderCard)); + gSaveBlock1Ptr->mysteryGift.cardCrc = CALC_CRC(gSaveBlock1Ptr->mysteryGift.card); + metadata = &gSaveBlock1Ptr->mysteryGift.cardMetadata; + metadata->iconSpecies = (&gSaveBlock1Ptr->mysteryGift.card)->iconSpecies; + return TRUE; +} + +bool32 ValidateSavedWonderCard(void) +{ + if (gSaveBlock1Ptr->mysteryGift.cardCrc != CALC_CRC(gSaveBlock1Ptr->mysteryGift.card)) + return FALSE; + if (!ValidateWonderCard(&gSaveBlock1Ptr->mysteryGift.card)) + return FALSE; + if (!ValidateRamScript()) + return FALSE; + return TRUE; +} + +static bool32 ValidateWonderCard(const struct WonderCard * card) +{ + if (card->flagId == 0) + return FALSE; + if (card->type >= CARD_TYPE_COUNT) + return FALSE; + if (!(card->sendType == SEND_TYPE_DISALLOWED + || card->sendType == SEND_TYPE_ALLOWED + || card->sendType == SEND_TYPE_ALLOWED_ALWAYS)) + return FALSE; + if (card->bgType >= NUM_WONDER_BGS) + return FALSE; + if (card->maxStamps > MAX_STAMP_CARD_STAMPS) + return FALSE; + return TRUE; +} + +bool32 IsSendingSavedWonderCardAllowed(void) +{ + const struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->sendType == SEND_TYPE_DISALLOWED) + return FALSE; + return TRUE; +} + +static void ClearSavedWonderCard(void) +{ + CpuFill32(0, &gSaveBlock1Ptr->mysteryGift.card, sizeof(gSaveBlock1Ptr->mysteryGift.card)); + gSaveBlock1Ptr->mysteryGift.cardCrc = 0; +} + +static void ClearSavedWonderCardMetadata(void) +{ + CpuFill32(0, GetSavedWonderCardMetadata(), sizeof(gSaveBlock1Ptr->mysteryGift.cardMetadata)); + gSaveBlock1Ptr->mysteryGift.cardMetadataCrc = 0; +} + +u16 GetWonderCardFlagId(void) +{ + if (ValidateSavedWonderCard()) + return gSaveBlock1Ptr->mysteryGift.card.flagId; + return 0; +} + +void DisableWonderCardSending(struct WonderCard * card) +{ + if (card->sendType == SEND_TYPE_ALLOWED) + card->sendType = SEND_TYPE_DISALLOWED; +} + +static bool32 IsWonderCardFlagIDInValidRange(u16 flagId) +{ + if (flagId >= WONDER_CARD_FLAG_OFFSET && flagId < WONDER_CARD_FLAG_OFFSET + NUM_WONDER_CARD_FLAGS) + return TRUE; + return FALSE; +} + +bool32 IsSavedWonderCardGiftNotReceived(void) +{ + u16 value = GetWonderCardFlagId(); + if (!IsWonderCardFlagIDInValidRange(value)) + return FALSE; + + // If flag is set, player has received gift from this card + if (FlagGet(sReceivedGiftFlags[value - WONDER_CARD_FLAG_OFFSET]) == TRUE) + return FALSE; + return TRUE; +} + +static s32 GetNumStampsInMetadata(const struct WonderCardMetadata * data, s32 size) +{ + s32 numStamps = 0; + s32 i; + for (i = 0; i < size; i++) + { + if (data->stampData[STAMP_ID][i] && data->stampData[STAMP_SPECIES][i]) + numStamps++; + } + return numStamps; +} + +static bool32 IsStampInMetadata(const struct WonderCardMetadata * metadata, const u16 * stamp, s32 maxStamps) +{ + s32 i; + for (i = 0; i < maxStamps; i++) + { + if (metadata->stampData[STAMP_ID][i] == stamp[STAMP_ID]) + return TRUE; + if (metadata->stampData[STAMP_SPECIES][i] == stamp[STAMP_SPECIES]) + return TRUE; + } + return FALSE; +} + +static bool32 ValidateStamp(const u16 * stamp) +{ + if (stamp[STAMP_ID] == 0) + return FALSE; + if (stamp[STAMP_SPECIES] == SPECIES_NONE) + return FALSE; + if (stamp[STAMP_SPECIES] >= NUM_SPECIES) + return FALSE; + return TRUE; +} + +static s32 GetNumStampsInSavedCard(void) +{ + struct WonderCard * card; + if (!ValidateSavedWonderCard()) + return 0; + card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type != CARD_TYPE_STAMP) + return 0; + return GetNumStampsInMetadata(&gSaveBlock1Ptr->mysteryGift.cardMetadata, card->maxStamps); +} + +bool32 MysteryGift_TrySaveStamp(const u16 * stamp) +{ + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + s32 maxStamps = card->maxStamps; + s32 i; + if (!ValidateStamp(stamp)) + return FALSE; + if (IsStampInMetadata(&gSaveBlock1Ptr->mysteryGift.cardMetadata, stamp, maxStamps)) + return FALSE; + for (i = 0; i < maxStamps; i++) + { + if (gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[STAMP_ID][i] == 0 + && gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[STAMP_SPECIES][i] == SPECIES_NONE) + { + gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[STAMP_ID][i] = stamp[STAMP_ID]; + gSaveBlock1Ptr->mysteryGift.cardMetadata.stampData[STAMP_SPECIES][i] = stamp[STAMP_SPECIES]; + return TRUE; + } + } + return FALSE; +} + +#define GAME_DATA_VALID_VAR 0x101 + +#if defined(FIRERED) +#define VERSION_CODE 1 +#elif defined(LEAFGREEN) +#define VERSION_CODE 2 +#endif + +void MysteryGift_LoadLinkGameData(struct MysteryGiftLinkGameData * data) +{ + s32 i; + CpuFill32(0, data, sizeof(*data)); + // Magic + data->unk_00 = GAME_DATA_VALID_VAR; + data->unk_04 = 1; + data->unk_08 = 1; + data->unk_0C = 1; + data->unk_10 = VERSION_CODE; + + // Check whether a card already exists + if (ValidateSavedWonderCard()) + { + // Populate fields + data->flagId = GetSavedWonderCard()->flagId; + data->cardMetadata = *GetSavedWonderCardMetadata(); + data->maxStamps = GetSavedWonderCard()->maxStamps; + } + else + { + data->flagId = 0; + } + + for (i = 0; i < NUM_QUESTIONNAIRE_WORDS; i++) + data->questionnaireWords[i] = gSaveBlock1Ptr->mysteryGift.questionnaireWords[i]; + + CopyTrainerId(data->playerTrainerId, gSaveBlock2Ptr->playerTrainerId); + StringCopy(data->playerName, gSaveBlock2Ptr->playerName); + for (i = 0; i < EASY_CHAT_BATTLE_WORDS_COUNT; i++) + data->easyChatProfile[i] = gSaveBlock1Ptr->easyChatProfile[i]; + + memcpy(data->gameCode, RomHeaderGameCode, GAME_CODE_LENGTH); + data->version = RomHeaderSoftwareVersion; +} + +bool32 MysteryGift_ValidateLinkGameData(const struct MysteryGiftLinkGameData * data) +{ + if (data->unk_00 != GAME_DATA_VALID_VAR) + return FALSE; + if (!(data->unk_04 & 1)) + return FALSE; + if (!(data->unk_08 & 1)) + return FALSE; + if (!(data->unk_0C & 1)) + return FALSE; + if (!(data->unk_10 & 0x0F)) + return FALSE; + return TRUE; +} + +u32 MysteryGift_CompareCardFlags(const u16 * flagId, const struct MysteryGiftLinkGameData * data, const void *unused) +{ + // Has a Wonder Card already? + if (data->flagId == 0) + return 0; + + // Has this Wonder Card already? + if (*flagId == data->flagId) + return 1; + + // Player has a different Wonder Card + return 2; +} + +u32 MysteryGift_CheckStamps(const u16 * stamp, const struct MysteryGiftLinkGameData * data, const void *unused) +{ + s32 stampsMissing = data->maxStamps - GetNumStampsInMetadata(&data->cardMetadata, data->maxStamps); + + // Has full stamp card? + if (stampsMissing == 0) + return 1; + + // Already has stamp? + if (IsStampInMetadata(&data->cardMetadata, stamp, data->maxStamps)) + return 3; + + // Only 1 empty stamp left? + if (stampsMissing == 1) + return 4; + + // This is a new stamp + return 2; +} + +bool32 MysteryGift_DoesQuestionnaireMatch(const struct MysteryGiftLinkGameData * data, const u16 * words) +{ + s32 i; + for (i = 0; i < NUM_QUESTIONNAIRE_WORDS; i++) + { + if (data->questionnaireWords[i] != words[i]) + return FALSE; + } + return TRUE; +} + +static s32 GetNumStampsInLinkData(const struct MysteryGiftLinkGameData * data) +{ + return GetNumStampsInMetadata(&data->cardMetadata, data->maxStamps); +} + +u16 MysteryGift_GetCardStatFromLinkData(const struct MysteryGiftLinkGameData * data, u32 stat) +{ + switch (stat) + { + case CARD_STAT_BATTLES_WON: + return data->cardMetadata.battlesWon; + case CARD_STAT_BATTLES_LOST: + return data->cardMetadata.battlesLost; + case CARD_STAT_NUM_TRADES: + return data->cardMetadata.numTrades; + case CARD_STAT_NUM_STAMPS: + return GetNumStampsInLinkData(data); + case CARD_STAT_MAX_STAMPS: + return data->maxStamps; + default: + AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 825); + return 0; + } +} + +static void IncrementCardStat(u32 statType) +{ + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_LINK_STAT) + { + u16 * stat = NULL; + switch (statType) + { + case CARD_STAT_BATTLES_WON: + stat = &gSaveBlock1Ptr->mysteryGift.cardMetadata.battlesWon; + break; + case CARD_STAT_BATTLES_LOST: + stat = &gSaveBlock1Ptr->mysteryGift.cardMetadata.battlesLost; + break; + case CARD_STAT_NUM_TRADES: + stat = &gSaveBlock1Ptr->mysteryGift.cardMetadata.numTrades; + break; + case CARD_STAT_NUM_STAMPS: + case CARD_STAT_MAX_STAMPS: + break; + } + if (stat == NULL) + { + AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 868); + } + else if (++(*stat) > MAX_WONDER_CARD_STAT) + { + *stat = MAX_WONDER_CARD_STAT; + } + } +} + +u16 MysteryGift_GetCardStat(u32 stat) +{ + switch (stat) + { + case CARD_STAT_BATTLES_WON: + { + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_LINK_STAT) + { + struct WonderCardMetadata * metadata = &gSaveBlock1Ptr->mysteryGift.cardMetadata; + return metadata->battlesWon; + } + break; + } + case CARD_STAT_BATTLES_LOST: + { + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_LINK_STAT) + { + struct WonderCardMetadata * metadata = &gSaveBlock1Ptr->mysteryGift.cardMetadata; + return metadata->battlesLost; + } + break; + } + case CARD_STAT_NUM_TRADES: + { + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_LINK_STAT) + { + struct WonderCardMetadata * metadata = &gSaveBlock1Ptr->mysteryGift.cardMetadata; + return metadata->numTrades; + } + break; + } + case CARD_STAT_NUM_STAMPS: + { + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_STAMP) + return GetNumStampsInSavedCard(); + break; + } + case CARD_STAT_MAX_STAMPS: + { + struct WonderCard * card = &gSaveBlock1Ptr->mysteryGift.card; + if (card->type == CARD_TYPE_STAMP) + return card->maxStamps; + break; + } + } + AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 913); + return 0; +} + +void MysteryGift_DisableStats(void) +{ + sStatsEnabled = FALSE; +} + +bool32 MysteryGift_TryEnableStatsByFlagId(u16 flagId) +{ + sStatsEnabled = FALSE; + if (flagId == 0) + return FALSE; + if (!ValidateSavedWonderCard()) + return FALSE; + if (gSaveBlock1Ptr->mysteryGift.card.flagId != flagId) + return FALSE; + sStatsEnabled = TRUE; + return TRUE; +} + +void MysteryGift_TryIncrementStat(u32 stat, u32 trainerId) +{ + if (sStatsEnabled) + { + switch (stat) + { + case CARD_STAT_NUM_TRADES: + IncrementCardStatForNewTrainer(CARD_STAT_NUM_TRADES, + trainerId, + gSaveBlock1Ptr->mysteryGift.trainerIds[1], + ARRAY_COUNT(gSaveBlock1Ptr->mysteryGift.trainerIds[1])); + break; + case CARD_STAT_BATTLES_WON: + IncrementCardStatForNewTrainer(CARD_STAT_BATTLES_WON, + trainerId, + gSaveBlock1Ptr->mysteryGift.trainerIds[0], + ARRAY_COUNT(gSaveBlock1Ptr->mysteryGift.trainerIds[0])); + break; + case CARD_STAT_BATTLES_LOST: + IncrementCardStatForNewTrainer(CARD_STAT_BATTLES_LOST, + trainerId, + gSaveBlock1Ptr->mysteryGift.trainerIds[0], + ARRAY_COUNT(gSaveBlock1Ptr->mysteryGift.trainerIds[0])); + break; + default: + AGB_ASSERT_EX(0, ABSPATH("mevent.c"), 988); + break; + } + } +} + +static void ClearSavedTrainerIds(void) +{ + CpuFill32(0, gSaveBlock1Ptr->mysteryGift.trainerIds, sizeof(gSaveBlock1Ptr->mysteryGift.trainerIds)); +} + +// Returns TRUE if it's a new trainer id, FALSE if an existing one. +// In either case the given trainerId is saved in element 0 +static bool32 RecordTrainerId(u32 trainerId, u32 * trainerIds, s32 size) +{ + s32 i; + s32 j; + + for (i = 0; i < size; i++) + { + if (trainerIds[i] == trainerId) + break; + } + + if (i == size) + { + // New trainer, shift array and insert new id at front + for (j = size - 1; j > 0; j--) + trainerIds[j] = trainerIds[j - 1]; + + trainerIds[0] = trainerId; + return TRUE; + } + else + { + // Existing trainer, shift back to old slot and move id to front + for (j = i; j > 0; j--) + trainerIds[j] = trainerIds[j - 1]; + + trainerIds[0] = trainerId; + return FALSE; + } +} + +static void IncrementCardStatForNewTrainer(u32 stat, u32 trainerId, u32 * trainerIds, s32 size) +{ + if (RecordTrainerId(trainerId, trainerIds, size)) + IncrementCardStat(stat); +} diff --git a/src/mystery_gift_client.c b/src/mystery_gift_client.c new file mode 100644 index 000000000..ab25ceb43 --- /dev/null +++ b/src/mystery_gift_client.c @@ -0,0 +1,300 @@ +#include "global.h" +#include "gflib.h" +#include "decompress.h" +#include "overworld.h" +#include "script.h" +#include "battle_tower.h" +#include "mystery_event_script.h" +#include "mystery_gift.h" +#include "mystery_gift_client.h" +#include "mystery_gift_server.h" + +enum { + FUNC_INIT, + FUNC_DONE, + FUNC_RECV, + FUNC_SEND, + FUNC_RUN, + FUNC_WAIT, + FUNC_RUN_MEVENT, + FUNC_RUN_BUFFER, +}; + +static EWRAM_DATA struct MysteryGiftClient * sClient = NULL; + +static void MysteryGiftClient_Init(struct MysteryGiftClient *, u32, u32); +static u32 MysteryGiftClient_CallFunc(struct MysteryGiftClient *); +static void MysteryGiftClient_Free(struct MysteryGiftClient *); + +extern const struct MysteryGiftClientCmd gMysteryGiftClientScript_Init[]; + +void MysteryGiftClient_Create(void) +{ + sClient = AllocZeroed(sizeof(*sClient)); + MysteryGiftClient_Init(sClient, 1, 0); +} + +u32 MysteryGiftClient_Run(u16 * endVal) +{ + u32 result; + if (sClient == NULL) + return CLI_RET_END; + result = MysteryGiftClient_CallFunc(sClient); + if (result == CLI_RET_END) + { + *endVal = sClient->param; + MysteryGiftClient_Free(sClient); + FREE_AND_SET_NULL(sClient); + } + return result; +} + +void MysteryGiftClient_AdvanceState(void) +{ + sClient->funcState++; +} + +void *MysteryGiftClient_GetMsg(void) +{ + return sClient->msg; +} + +void MysteryGiftClient_SetParam(u32 val) +{ + sClient->param = val; +} + +static void MysteryGiftClient_Init(struct MysteryGiftClient * client, u32 sendPlayerId, u32 recvPlayerId) +{ + client->unused = 0; + client->funcId = FUNC_INIT; + client->funcState = 0; + client->sendBuffer = AllocZeroed(MG_LINK_BUFFER_SIZE); + client->recvBuffer = AllocZeroed(MG_LINK_BUFFER_SIZE); + client->script = AllocZeroed(MG_LINK_BUFFER_SIZE); + client->msg = AllocZeroed(CLIENT_MAX_MSG_SIZE); + MysteryGiftLink_Init(&client->link, sendPlayerId, recvPlayerId); +} + +static void MysteryGiftClient_Free(struct MysteryGiftClient * client) +{ + Free(client->sendBuffer); + Free(client->recvBuffer); + Free(client->script); + Free(client->msg); +} + +static void MysteryGiftClient_CopyRecvScript(struct MysteryGiftClient * client) +{ + memcpy(client->script, client->recvBuffer, MG_LINK_BUFFER_SIZE); + client->cmdidx = 0; +} + +static void MysteryGiftClient_InitSendWord(struct MysteryGiftClient * client, u32 ident, u32 word) +{ + CpuFill32(0, client->sendBuffer, MG_LINK_BUFFER_SIZE); + *(u32 *)client->sendBuffer = word; + MysteryGiftLink_InitSend(&client->link, ident, client->sendBuffer, sizeof(word)); +} + +static u32 Client_Init(struct MysteryGiftClient * client) +{ + memcpy(client->script, gMysteryGiftClientScript_Init, MG_LINK_BUFFER_SIZE); + client->cmdidx = 0; + client->funcId = FUNC_RUN; + client->funcState = 0; + return CLI_RET_INIT; +} + +static u32 Client_Done(struct MysteryGiftClient * client) +{ + return CLI_RET_END; +} + +static u32 Client_Recv(struct MysteryGiftClient * client) +{ + if (MysteryGiftLink_Recv(&client->link)) + { + client->funcId = FUNC_RUN; + client->funcState = 0; + } + return CLI_RET_ACTIVE; +} + +static u32 Client_Send(struct MysteryGiftClient * client) +{ + if (MysteryGiftLink_Send(&client->link)) + { + client->funcId = FUNC_RUN; + client->funcState = 0; + } + return CLI_RET_ACTIVE; +} + +static u32 Client_Run(struct MysteryGiftClient * client) +{ + // process command + struct MysteryGiftClientCmd * cmd = &client->script[client->cmdidx]; + client->cmdidx++; + switch (cmd->instr) + { + case CLI_NONE: + break; + case CLI_RETURN: + client->param = cmd->parameter; // Set for endVal in MysteryGiftClient_Run + client->funcId = FUNC_DONE; + client->funcState = 0; + break; + case CLI_RECV: + MysteryGiftLink_InitRecv(&client->link, cmd->parameter, client->recvBuffer); + client->funcId = FUNC_RECV; + client->funcState = 0; + break; + case CLI_SEND_LOADED: + // Send without a MysteryGiftLink_InitSend + // Sends whatever has been loaded already + client->funcId = FUNC_SEND; + client->funcState = 0; + break; + case CLI_SEND_READY_END: + MysteryGiftLink_InitSend(&client->link, MG_LINKID_READY_END, client->sendBuffer, 0); + client->funcId = FUNC_SEND; + client->funcState = 0; + break; + case CLI_SEND_STAT: + MysteryGiftClient_InitSendWord(client, MG_LINKID_GAME_STAT, GetGameStat(cmd->parameter)); + client->funcId = FUNC_SEND; + client->funcState = 0; + break; + case CLI_COPY_RECV_IF_N: + if (client->param == FALSE) + MysteryGiftClient_CopyRecvScript(client); + break; + case CLI_COPY_RECV_IF: + if (client->param == TRUE) + MysteryGiftClient_CopyRecvScript(client); + break; + case CLI_COPY_RECV: + MysteryGiftClient_CopyRecvScript(client); + break; + case CLI_YES_NO: + memcpy(client->msg, client->recvBuffer, CLIENT_MAX_MSG_SIZE); + client->funcId = FUNC_WAIT; + client->funcState = 0; + return CLI_RET_YES_NO; + case CLI_PRINT_MSG: + memcpy(client->msg, client->recvBuffer, CLIENT_MAX_MSG_SIZE); + client->funcId = FUNC_WAIT; + client->funcState = 0; + return CLI_RET_PRINT_MSG; + case CLI_COPY_MSG: + memcpy(client->msg, client->recvBuffer, CLIENT_MAX_MSG_SIZE); + client->funcId = FUNC_WAIT; + client->funcState = 0; + return CLI_RET_COPY_MSG; + case CLI_ASK_TOSS: + client->funcId = FUNC_WAIT; + client->funcState = 0; + return CLI_RET_ASK_TOSS; + case CLI_LOAD_GAME_DATA: + MysteryGift_LoadLinkGameData(client->sendBuffer); + MysteryGiftLink_InitSend(&client->link, MG_LINKID_GAME_DATA, client->sendBuffer, sizeof(struct MysteryGiftLinkGameData)); + break; + case CLI_LOAD_TOSS_RESPONSE: + // param here is set by MG_STATE_CLIENT_ASK_TOSS or MG_STATE_CLIENT_ASK_TOSS_UNRECEIVED + MysteryGiftClient_InitSendWord(client, MG_LINKID_RESPONSE, client->param); + break; + case CLI_SAVE_CARD: + SaveWonderCard(client->recvBuffer); + break; + case CLI_SAVE_NEWS: + if (!IsWonderNewsSameAsSaved(client->recvBuffer)) + { + SaveWonderNews(client->recvBuffer); + MysteryGiftClient_InitSendWord(client, MG_LINKID_RESPONSE, FALSE); + } + else + { + // Wonder News has already been saved (or is invalid). + // Prepare a signal to indicate it was not saved. + MysteryGiftClient_InitSendWord(client, MG_LINKID_RESPONSE, TRUE); + } + break; + case CLI_RUN_MEVENT_SCRIPT: + client->funcId = FUNC_RUN_MEVENT; + client->funcState = 0; + break; + case CLI_SAVE_STAMP: + MysteryGift_TrySaveStamp(client->recvBuffer); + break; + case CLI_SAVE_RAM_SCRIPT: + InitRamScript_NoObjectEvent(client->recvBuffer, sizeof(struct RamScriptData)); + break; + case CLI_RECV_EREADER_TRAINER: + memcpy(&gSaveBlock2Ptr->battleTower.ereaderTrainer, client->recvBuffer, sizeof(gSaveBlock2Ptr->battleTower.ereaderTrainer)); + ValidateEReaderTrainer(); + break; + case CLI_RUN_BUFFER_SCRIPT: + memcpy(gDecompressionBuffer, client->recvBuffer, MG_LINK_BUFFER_SIZE); + client->funcId = FUNC_RUN_BUFFER; + client->funcState = 0; + break; + } + + return CLI_RET_ACTIVE; +} + +static u32 Client_Wait(struct MysteryGiftClient * client) +{ + if (client->funcState) + { + client->funcId = FUNC_RUN; + client->funcState = 0; + } + return CLI_RET_ACTIVE; +} + +static u32 Client_RunMysteryEventScript(struct MysteryGiftClient * client) +{ + switch (client->funcState) + { + case 0: + MEventScript_InitContext(client->recvBuffer); + client->funcState++; + break; + case 1: + if (!MEventScript_Run(&client->param)) + { + client->funcId = FUNC_RUN; + client->funcState = 0; + } + break; + } + return CLI_RET_ACTIVE; +} + +static u32 Client_RunBufferScript(struct MysteryGiftClient * client) +{ + u32 (*func)(u32 *, struct SaveBlock2 *, struct SaveBlock1 *) = (void *)gDecompressionBuffer; + if (func(&client->param, gSaveBlock2Ptr, gSaveBlock1Ptr) == 1) + { + client->funcId = FUNC_RUN; + client->funcState = 0; + } + return CLI_RET_ACTIVE; +} + +static u32 MysteryGiftClient_CallFunc(struct MysteryGiftClient * client) +{ + 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_RUN_MEVENT] = Client_RunMysteryEventScript, + [FUNC_RUN_BUFFER] = Client_RunBufferScript + }; + return funcs[client->funcId](client); +} diff --git a/src/mystery_gift_link.c b/src/mystery_gift_link.c new file mode 100644 index 000000000..f066574e9 --- /dev/null +++ b/src/mystery_gift_link.c @@ -0,0 +1,215 @@ +#include "global.h" +#include "util.h" +#include "link.h" +#include "link_rfu.h" +#include "mystery_gift_server.h" + +/* + Handles the link connection functions used by the Mystery Gift client/server. + Note: MysteryGiftLink is shortened to MGL for internal functions. +*/ + +struct SendRecvHeader +{ + u16 ident; + u16 crc; + u16 size; +}; + +static u32 MGL_Receive(struct MysteryGiftLink *); +static u32 MGL_Send(struct MysteryGiftLink *); + +u32 MysteryGiftLink_Recv(struct MysteryGiftLink * link) +{ + return link->recvFunc(link); +} + +u32 MysteryGiftLink_Send(struct MysteryGiftLink * link) +{ + return link->sendFunc(link); +} + +void MysteryGiftLink_Init(struct MysteryGiftLink * link, u32 sendPlayerId, u32 recvPlayerId) +{ + link->sendPlayerId = sendPlayerId; + link->recvPlayerId = recvPlayerId; + link->state = 0; + link->sendCRC = 0; + link->sendSize = 0; + link->sendCounter = 0; + link->recvCRC = 0; + link->recvSize = 0; + link->recvCounter = 0; + link->sendBuffer = NULL; + link->recvBuffer = NULL; + link->sendFunc = MGL_Send; + link->recvFunc = MGL_Receive; +} + +void MysteryGiftLink_InitSend(struct MysteryGiftLink * link, u32 ident, const void *src, u32 size) +{ + link->state = 0; + link->sendIdent = ident; + link->sendCounter = 0; + link->sendCRC = 0; + if (size != 0) + link->sendSize = size; + else + link->sendSize = MG_LINK_BUFFER_SIZE; + link->sendBuffer = src; +} + +void MysteryGiftLink_InitRecv(struct MysteryGiftLink * link, u32 ident, void *dest) +{ + link->state = 0; + link->recvIdent = ident; + link->recvCounter = 0; + link->recvCRC = 0; + link->recvSize = 0; + link->recvBuffer = dest; +} + +static void MGL_ReceiveBlock(u32 playerId, void *dest, size_t size) +{ + memcpy(dest, gBlockRecvBuffer[playerId], size); +} + +static bool32 MGL_HasReceived(u32 playerId) +{ + if ((GetBlockReceivedStatus() >> playerId) & 1) + return TRUE; + else + return FALSE; +} + +static void MGL_ResetReceived(u32 playerId) +{ + ResetBlockReceivedFlag(playerId); +} + +static bool32 MGL_Receive(struct MysteryGiftLink * link) +{ + struct SendRecvHeader header; + + switch (link->state) + { + case 0: + if (MGL_HasReceived(link->recvPlayerId)) + { + MGL_ReceiveBlock(link->recvPlayerId, &header, sizeof(header)); + link->recvSize = header.size; + link->recvCRC = header.crc; + if (link->recvSize > MG_LINK_BUFFER_SIZE) + { + LinkRfu_FatalError(); + return FALSE; + } + else if (link->recvIdent != header.ident) + { + LinkRfu_FatalError(); + return FALSE; + } + else + { + link->recvCounter = 0; + MGL_ResetReceived(link->recvPlayerId); + link->state++; + } + } + break; + case 1: + if (MGL_HasReceived(link->recvPlayerId)) + { + size_t blocksize = link->recvCounter * 252; + if (link->recvSize - blocksize <= 252) + { + MGL_ReceiveBlock(link->recvPlayerId, link->recvBuffer + blocksize, link->recvSize - blocksize); + link->recvCounter++; + link->state++; + } + else + { + MGL_ReceiveBlock(link->recvPlayerId, link->recvBuffer + blocksize, 252); + link->recvCounter++; + } + MGL_ResetReceived(link->recvPlayerId); + } + break; + case 2: + if (CalcCRC16WithTable(link->recvBuffer, link->recvSize) != link->recvCRC) + { + LinkRfu_FatalError(); + return FALSE; + } + else + { + link->state = 0; + return TRUE; + } + break; + } + + return FALSE; +} + +static bool32 MGL_Send(struct MysteryGiftLink * link) +{ + struct SendRecvHeader header; + + switch (link->state) + { + case 0: + if (IsLinkTaskFinished()) + { + header.ident = link->sendIdent; + header.size = link->sendSize; + header.crc = CalcCRC16WithTable(link->sendBuffer, link->sendSize); + link->sendCRC = header.crc; + link->sendCounter = 0; + SendBlock(0, &header, sizeof(header)); + link->state++; + } + break; + case 1: + if (IsLinkTaskFinished()) + { + if (MGL_HasReceived(link->sendPlayerId)) + { + size_t blocksize; + MGL_ResetReceived(link->sendPlayerId); + blocksize = 252 * link->sendCounter; + if (link->sendSize - blocksize <= 252) + { + SendBlock(0, link->sendBuffer + blocksize, link->sendSize - blocksize); + link->sendCounter++; + link->state++; + } + else + { + SendBlock(0, link->sendBuffer + blocksize, 252); + link->sendCounter++; + } + } + } + break; + case 2: + if (IsLinkTaskFinished()) + { + if (CalcCRC16WithTable(link->sendBuffer, link->sendSize) != link->sendCRC) + LinkRfu_FatalError(); + else + link->state++; + } + break; + case 3: + if (MGL_HasReceived(link->sendPlayerId)) + { + MGL_ResetReceived(link->sendPlayerId); + link->state = 0; + return TRUE; + } + break; + } + + return FALSE; +} diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c index b07a57ee0..7a711aacf 100644 --- a/src/mystery_gift_menu.c +++ b/src/mystery_gift_menu.c @@ -9,44 +9,47 @@ #include "title_screen.h" #include "list_menu.h" #include "link_rfu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "save.h" #include "link.h" #include "event_data.h" -#include "mevent_server.h" -#include "menews_jisan.h" +#include "mystery_gift_server.h" +#include "mystery_gift_client.h" +#include "wonder_news.h" #include "help_system.h" #include "strings.h" +#include "decompress.h" +#include "constants/cable_club.h" #include "constants/songs.h" #include "constants/union_room.h" EWRAM_DATA u8 sDownArrowCounterAndYCoordIdx[8] = {}; EWRAM_DATA bool8 gGiftIsFromEReader = FALSE; -void task_add_00_mystery_gift(void); -void task00_mystery_gift(u8 taskId); -void task_add_00_ereader(void); +static void CreateMysteryGiftTask(void); +static void Task_MysteryGift(u8 taskId); +extern void CreateEReaderTask(void); -const u16 gUnkTextboxBorderPal[] = INCBIN_U16("graphics/interface/unk_textbox_border.gbapal"); -const u32 gUnkTextboxBorderGfx[] = INCBIN_U32("graphics/interface/unk_textbox_border.4bpp.lz"); +static const u16 sTextboxBorder_Pal[] = INCBIN_U16("graphics/interface/mystery_gift_textbox_border.gbapal"); +static const u32 sTextboxBorder_Gfx[] = INCBIN_U32("graphics/interface/mystery_gift_textbox_border.4bpp.lz"); struct MysteryGiftTaskData { - u16 curPromptWindowId; - u16 unk2; - u16 unk4; - u16 unk6; + u16 var; // Multipurpose + u16 unused1; + u16 unused2; + u16 unused3; u8 state; u8 textState; - u8 unkA; - u8 unkB; - u8 IsCardOrNews; - u8 source; - u8 prevPromptWindowId; - u8 * buffer; + u8 unused4; + u8 unused5; + bool8 isWonderNews; + bool8 sourceIsFriend; + u8 msgId; + u8 * clientMsg; }; -const struct BgTemplate sBGTemplates[] = { +static const struct BgTemplate sBGTemplates[] = { { .bg = 0, .charBaseIndex = 2, @@ -82,7 +85,7 @@ const struct BgTemplate sBGTemplates[] = { } }; -const struct WindowTemplate sMainWindows[] = { +static const struct WindowTemplate sMainWindows[] = { { .bg = 0x00, .tilemapLeft = 0x00, @@ -107,12 +110,11 @@ const struct WindowTemplate sMainWindows[] = { .height = 0x05, .paletteNum = 0x0d, .baseBlock = 0x004f - }, { - 0xFF - } + }, + DUMMY_WIN_TEMPLATE }; -const struct WindowTemplate sWindowTemplate_PromptYesOrNo_Width28 = { +static const struct WindowTemplate sWindowTemplate_YesNoMsg_Wide = { .bg = 0x00, .tilemapLeft = 0x01, .tilemapTop = 0x0f, @@ -122,7 +124,7 @@ const struct WindowTemplate sWindowTemplate_PromptYesOrNo_Width28 = { .baseBlock = 0x00e5 }; -const struct WindowTemplate sWindowTemplate_PromptYesOrNo_Width20 = { +static const struct WindowTemplate sWindowTemplate_YesNoMsg = { .bg = 0x00, .tilemapLeft = 0x01, .tilemapTop = 0x0f, @@ -132,7 +134,7 @@ const struct WindowTemplate sWindowTemplate_PromptYesOrNo_Width20 = { .baseBlock = 0x00e5 }; -const struct WindowTemplate sMysteryGiftMenuWindowTemplate = { +static const struct WindowTemplate sWindowTemplate_GiftSelect = { .bg = 0x00, .tilemapLeft = 0x01, .tilemapTop = 0x0f, @@ -142,7 +144,7 @@ const struct WindowTemplate sMysteryGiftMenuWindowTemplate = { .baseBlock = 0x00e5 }; -const struct WindowTemplate sWindowTemplate_ThreeOptions = { +static const struct WindowTemplate sWindowTemplate_ThreeOptions = { .bg = 0x00, .tilemapLeft = 0x08, .tilemapTop = 0x05, @@ -152,7 +154,7 @@ const struct WindowTemplate sWindowTemplate_ThreeOptions = { .baseBlock = 0x0155 }; -const struct WindowTemplate sWindowTemplate_YesNoBox = { +static const struct WindowTemplate sWindowTemplate_YesNoBox = { .bg = 0x00, .tilemapLeft = 0x17, .tilemapTop = 0x0f, @@ -162,7 +164,7 @@ const struct WindowTemplate sWindowTemplate_YesNoBox = { .baseBlock = 0x0155 }; -const struct WindowTemplate sWindowTemplate_7by8 = { +static const struct WindowTemplate sWindowTemplate_GiftSelect_3Options = { .bg = 0x00, .tilemapLeft = 0x16, .tilemapTop = 0x0c, @@ -172,7 +174,7 @@ const struct WindowTemplate sWindowTemplate_7by8 = { .baseBlock = 0x0155 }; -const struct WindowTemplate sWindowTemplate_7by6 = { +static const struct WindowTemplate sWindowTemplate_GiftSelect_2Options = { .bg = 0x00, .tilemapLeft = 0x16, .tilemapTop = 0x0e, @@ -182,7 +184,7 @@ const struct WindowTemplate sWindowTemplate_7by6 = { .baseBlock = 0x0155 }; -const struct WindowTemplate sWindowTemplate_7by4 = { +static const struct WindowTemplate sWindowTemplate_GiftSelect_1Option = { .bg = 0x00, .tilemapLeft = 0x16, .tilemapTop = 0x0f, @@ -192,19 +194,19 @@ const struct WindowTemplate sWindowTemplate_7by4 = { .baseBlock = 0x0155 }; -const struct ListMenuItem sListMenuItems_CardsOrNews[] = { +static const struct ListMenuItem sListMenuItems_CardsOrNews[] = { { gText_WonderCards, 0 }, { gText_WonderNews, 1 }, - { gText_Exit3, -2 } + { gText_Exit3, LIST_CANCEL } }; -const struct ListMenuItem sListMenuItems_WirelessOrFriend[] = { +static const struct ListMenuItem sListMenuItems_WirelessOrFriend[] = { { gText_WirelessCommunication, 0 }, { gText_Friend2, 1 }, - { gFameCheckerText_Cancel, -2 } + { gFameCheckerText_Cancel, LIST_CANCEL } }; -const struct ListMenuTemplate sListMenuTemplate_ThreeOptions = { +static const struct ListMenuTemplate sListMenuTemplate_ThreeOptions = { .items = NULL, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -225,31 +227,31 @@ const struct ListMenuTemplate sListMenuTemplate_ThreeOptions = { .cursorKind = 0 }; -const struct ListMenuItem sListMenuItems_ReceiveSendToss[] = { +static const struct ListMenuItem sListMenuItems_ReceiveSendToss[] = { { gText_Receive, 0 }, { gText_Send, 1 }, { gText_Toss, 2 }, - { gFameCheckerText_Cancel, -2 } + { gFameCheckerText_Cancel, LIST_CANCEL } }; -const struct ListMenuItem sListMenuItems_ReceiveToss[] = { +static const struct ListMenuItem sListMenuItems_ReceiveToss[] = { { gText_Receive, 0 }, { gText_Toss, 2 }, - { gFameCheckerText_Cancel, -2 } + { gFameCheckerText_Cancel, LIST_CANCEL } }; -const struct ListMenuItem sListMenuItems_ReceiveSend[] = { +static const struct ListMenuItem sListMenuItems_ReceiveSend[] = { { gText_Receive, 0 }, { gText_Send, 1 }, - { gFameCheckerText_Cancel, -2 } + { gFameCheckerText_Cancel, LIST_CANCEL } }; -const struct ListMenuItem sListMenuItems_Receive[] = { +static const struct ListMenuItem sListMenuItems_Receive[] = { { gText_Receive, 0 }, - { gFameCheckerText_Cancel, -2 } + { gFameCheckerText_Cancel, LIST_CANCEL } }; -const struct ListMenuTemplate sListMenu_ReceiveSendToss = { +static const struct ListMenuTemplate sListMenu_ReceiveSendToss = { .items = sListMenuItems_ReceiveSendToss, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -270,7 +272,7 @@ const struct ListMenuTemplate sListMenu_ReceiveSendToss = { .cursorKind = 0 }; -const struct ListMenuTemplate sListMenu_ReceiveToss = { +static const struct ListMenuTemplate sListMenu_ReceiveToss = { .items = sListMenuItems_ReceiveToss, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -291,7 +293,7 @@ const struct ListMenuTemplate sListMenu_ReceiveToss = { .cursorKind = 0 }; -const struct ListMenuTemplate sListMenu_ReceiveSend = { +static const struct ListMenuTemplate sListMenu_ReceiveSend = { .items = sListMenuItems_ReceiveSend, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -312,7 +314,7 @@ const struct ListMenuTemplate sListMenu_ReceiveSend = { .cursorKind = 0 }; -const struct ListMenuTemplate sListMenu_Receive = { +static const struct ListMenuTemplate sListMenu_Receive = { .items = sListMenuItems_Receive, .moveCursorFunc = ListMenuDefaultCursorMoveFunc, .itemPrintFunc = NULL, @@ -340,14 +342,14 @@ static const u8 *const sUnusedMenuTexts[] = { gText_ReturnToTitle }; -ALIGNED(4) const u8 sMG_Ereader_TextColor_1[3] = { 0, 1, 2 }; -ALIGNED(4) const u8 sMG_Ereader_TextColor_1_Copy[3] = { 0, 1, 2 }; -ALIGNED(4) const u8 sMG_Ereader_TextColor_2[3] = { 1, 2, 3 }; +ALIGNED(4) static const u8 sTextColors_TopMenu[3] = { 0, 1, 2 }; +ALIGNED(4) static const u8 sTextColors_TopMenu_Copy[3] = { 0, 1, 2 }; +ALIGNED(4) static const u8 sMG_Ereader_TextColor_2[3] = { 1, 2, 3 }; static const u8 sText_Test[] = _("テスト"); static const u8 sText_EonTicket[] = _("むげんのチケット"); -void vblankcb_mystery_gift_e_reader_run(void) +static void VBlankCB_MysteryGiftEReader(void) { ProcessSpriteCopyRequests(); LoadOam(); @@ -362,7 +364,7 @@ void CB2_MysteryGiftEReader(void) BuildOamBuffer(); } -bool32 HandleMysteryGiftOrEReaderSetup(s32 mg_or_ereader) +bool32 HandleMysteryGiftOrEReaderSetup(s32 isEReader) { switch (gMain.state) { @@ -375,24 +377,24 @@ bool32 HandleMysteryGiftOrEReaderSetup(s32 mg_or_ereader) ScanlineEffect_Stop(); ResetBgsAndClearDma3BusyFlags(1); - InitBgsFromTemplates(0, sBGTemplates, NELEMS(sBGTemplates)); - ChangeBgX(0, 0, 0); - ChangeBgY(0, 0, 0); - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ChangeBgX(2, 0, 0); - ChangeBgY(2, 0, 0); - ChangeBgX(3, 0, 0); - ChangeBgY(3, 0, 0); + InitBgsFromTemplates(0, sBGTemplates, ARRAY_COUNT(sBGTemplates)); + ChangeBgX(0, 0, BG_COORD_SET); + ChangeBgY(0, 0, BG_COORD_SET); + ChangeBgX(1, 0, BG_COORD_SET); + ChangeBgY(1, 0, BG_COORD_SET); + ChangeBgX(2, 0, BG_COORD_SET); + ChangeBgY(2, 0, BG_COORD_SET); + ChangeBgX(3, 0, BG_COORD_SET); + ChangeBgY(3, 0, BG_COORD_SET); - SetBgTilemapBuffer(3, Alloc(0x800)); - SetBgTilemapBuffer(2, Alloc(0x800)); - SetBgTilemapBuffer(1, Alloc(0x800)); - SetBgTilemapBuffer(0, Alloc(0x800)); + SetBgTilemapBuffer(3, Alloc(BG_SCREEN_SIZE)); + SetBgTilemapBuffer(2, Alloc(BG_SCREEN_SIZE)); + SetBgTilemapBuffer(1, Alloc(BG_SCREEN_SIZE)); + SetBgTilemapBuffer(0, Alloc(BG_SCREEN_SIZE)); LoadUserWindowGfx2(0, 10, 0xE0); LoadStdWindowGfxOnBg(0, 1, 0xF0); - DecompressAndLoadBgGfxUsingHeap(3, gUnkTextboxBorderGfx, 0x100, 0, 0); + DecompressAndLoadBgGfxUsingHeap(3, sTextboxBorder_Gfx, 0x100, 0, 0); InitWindows(sMainWindows); DeactivateAllTextPrinters(); ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON); @@ -402,13 +404,13 @@ bool32 HandleMysteryGiftOrEReaderSetup(s32 mg_or_ereader) gMain.state++; break; case 1: - LoadPalette(gUnkTextboxBorderPal, 0, 0x20); + LoadPalette(sTextboxBorder_Pal, 0, 0x20); LoadPalette(GetTextWindowPalette(2), 0xd0, 0x20); FillBgTilemapBufferRect(0, 0x000, 0, 0, 32, 32, 0x11); FillBgTilemapBufferRect(1, 0x000, 0, 0, 32, 32, 0x11); FillBgTilemapBufferRect(2, 0x000, 0, 0, 32, 32, 0x11); MG_DrawCheckerboardPattern(); - PrintMysteryGiftOrEReaderTopMenu(mg_or_ereader, 0); + PrintMysteryGiftOrEReaderTopMenu(isEReader, FALSE); gMain.state++; break; case 2: @@ -422,7 +424,7 @@ bool32 HandleMysteryGiftOrEReaderSetup(s32 mg_or_ereader) ShowBg(0); ShowBg(3); PlayBGM(MUS_MYSTERY_GIFT); - SetVBlankCallback(vblankcb_mystery_gift_e_reader_run); + SetVBlankCallback(VBlankCB_MysteryGiftEReader); EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL); return TRUE; } @@ -430,23 +432,23 @@ bool32 HandleMysteryGiftOrEReaderSetup(s32 mg_or_ereader) return FALSE; } -void c2_mystery_gift(void) +void CB2_InitMysteryGift(void) { - if (HandleMysteryGiftOrEReaderSetup(0)) + if (HandleMysteryGiftOrEReaderSetup(FALSE)) { SetMainCallback2(CB2_MysteryGiftEReader); gGiftIsFromEReader = FALSE; - task_add_00_mystery_gift(); + CreateMysteryGiftTask(); } } -void c2_ereader(void) +void CB2_InitEReader(void) { - if (HandleMysteryGiftOrEReaderSetup(1)) + if (HandleMysteryGiftOrEReaderSetup(TRUE)) { SetMainCallback2(CB2_MysteryGiftEReader); gGiftIsFromEReader = TRUE; - task_add_00_ereader(); + CreateEReaderTask(); } } @@ -461,22 +463,22 @@ void MainCB_FreeAllBuffersAndReturnToInitTitleScreen(void) SetMainCallback2(CB2_InitTitleScreen); } -void PrintMysteryGiftOrEReaderTopMenu(bool8 mg_or_ereader, bool32 usePickOkCancel) +void PrintMysteryGiftOrEReaderTopMenu(bool8 isEReader, bool32 useCancel) { - const u8 * src; + const u8 * options; s32 width; FillWindowPixelBuffer(0, 0x00); - if (!mg_or_ereader) + if (!isEReader) { - src = usePickOkCancel == TRUE ? gText_PickOKExit : gText_PickOKCancel; - AddTextPrinterParameterized4(0, FONT_2, 2, 2, 0, 0, sMG_Ereader_TextColor_1, 0, gText_MysteryGift2); - width = 222 - GetStringWidth(FONT_0, src, 0); - AddTextPrinterParameterized4(0, FONT_0, width, 2, 0, 0, sMG_Ereader_TextColor_1, 0, src); + options = useCancel == TRUE ? gText_PickOKExit : gText_PickOKCancel; + AddTextPrinterParameterized4(0, FONT_2, 2, 2, 0, 0, sTextColors_TopMenu, 0, gText_MysteryGift2); + width = 222 - GetStringWidth(FONT_0, options, 0); + AddTextPrinterParameterized4(0, FONT_0, width, 2, 0, 0, sTextColors_TopMenu, 0, options); } else { - AddTextPrinterParameterized4(0, FONT_2, 2, 2, 0, 0, sMG_Ereader_TextColor_1, 0, gJPText_MysteryGift); - AddTextPrinterParameterized4(0, FONT_0, 0x78, 2, 0, 0, sMG_Ereader_TextColor_1, 0, gJPText_DecideStop); + AddTextPrinterParameterized4(0, FONT_2, 2, 2, 0, 0, sTextColors_TopMenu, 0, gJPText_MysteryGift); + AddTextPrinterParameterized4(0, FONT_0, 120, 2, 0, 0, sTextColors_TopMenu, 0, gJPText_DecideStop); } CopyWindowToVram(0, COPYWIN_GFX); PutWindowTilemap(0); @@ -498,13 +500,9 @@ void MG_DrawCheckerboardPattern(void) for (j = 0; j < 32; j++) { if ((i & 1) != (j & 1)) - { FillBgTilemapBufferRect(3, 1, j, i + 2, 1, 1, 0x11); - } else - { FillBgTilemapBufferRect(3, 2, j, i + 2, 1, 1, 0x11); - } } } } @@ -533,13 +531,16 @@ void AddTextPrinterToWindow1(const u8 *str) CopyWindowToVram(1, COPYWIN_FULL); } -void ClearTextWindow(void) +static void ClearTextWindow(void) { rbox_fill_rectangle(1); ClearWindowTilemap(1); CopyWindowToVram(1, COPYWIN_MAP); } +#define DOWN_ARROW_X 208 +#define DOWN_ARROW_Y 20 + bool32 PrintMysteryGiftMenuMessage(u8 *textState, const u8 *str) { switch (*textState) @@ -548,7 +549,7 @@ bool32 PrintMysteryGiftMenuMessage(u8 *textState, const u8 *str) AddTextPrinterToWindow1(str); goto inc; case 1: - DrawDownArrow(1, 0xD0, 0x14, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); + DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); if (JOY_NEW(A_BUTTON | B_BUTTON)) { inc: @@ -556,7 +557,7 @@ bool32 PrintMysteryGiftMenuMessage(u8 *textState, const u8 *str) } break; case 2: - DrawDownArrow(1, 0xD0, 0x14, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); + DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); *textState = 0; ClearTextWindow(); return TRUE; @@ -567,26 +568,25 @@ bool32 PrintMysteryGiftMenuMessage(u8 *textState, const u8 *str) return FALSE; } -void HideDownArrow(void) +static void HideDownArrow(void) { - DrawDownArrow(1, 0xD0, 0x14, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); + DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); } -void ShowDownArrow(void) +static void ShowDownArrow(void) { - DrawDownArrow(1, 0xD0, 0x14, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); + DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]); } -bool32 unref_HideDownArrowAndWaitButton(u8 * textState) +// Unused +static bool32 HideDownArrowAndWaitButton(u8 * textState) { switch (*textState) { case 0: HideDownArrow(); if (JOY_NEW(A_BUTTON | B_BUTTON)) - { (*textState)++; - } break; case 1: ShowDownArrow(); @@ -596,12 +596,11 @@ bool32 unref_HideDownArrowAndWaitButton(u8 * textState) return FALSE; } -bool32 PrintStringAndWait2Seconds(u8 * counter, const u8 * str) +static bool32 PrintStringAndWait2Seconds(u8 * counter, const u8 * str) { if (*counter == 0) - { AddTextPrinterToWindow1(str); - } + if (++(*counter) > 120) { *counter = 0; @@ -614,7 +613,7 @@ bool32 PrintStringAndWait2Seconds(u8 * counter, const u8 * str) } } -u32 MysteryGift_HandleThreeOptionMenu(u8 * unused0, u16 * unused1, u8 whichMenu) +static u32 MysteryGift_HandleThreeOptionMenu(u8 * unused0, u16 * unused1, u8 whichMenu) { struct ListMenuTemplate listMenuTemplate = sListMenuTemplate_ThreeOptions; struct WindowTemplate windowTemplate = sWindowTemplate_ThreeOptions; @@ -624,13 +623,10 @@ u32 MysteryGift_HandleThreeOptionMenu(u8 * unused0, u16 * unused1, u8 whichMenu) u32 i; if (whichMenu == 0) - { listMenuTemplate.items = sListMenuItems_CardsOrNews; - } else - { listMenuTemplate.items = sListMenuItems_WirelessOrFriend; - } + width = 0; for (i = 0; i < listMenuTemplate.totalItems; i++) { @@ -642,7 +638,7 @@ u32 MysteryGift_HandleThreeOptionMenu(u8 * unused0, u16 * unused1, u8 whichMenu) windowTemplate.width = finalWidth; windowTemplate.tilemapLeft = (30 - finalWidth) / 2; response = DoMysteryGiftListMenu(&windowTemplate, &listMenuTemplate, 1, 0x00A, 0xE0); - if (response != -1) + if (response != LIST_NOTHING_CHOSEN) { ClearWindowTilemap(2); CopyWindowToVram(2, COPYWIN_MAP); @@ -658,15 +654,12 @@ s8 DoMysteryGiftYesNo(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, c switch (*textState) { case 0: + // Print question message StringExpandPlaceholders(gStringVar4, str); if (yesNoBoxPlacement == 0) - { - *windowId = AddWindow(&sWindowTemplate_PromptYesOrNo_Width28); - } + *windowId = AddWindow(&sWindowTemplate_YesNoMsg_Wide); else - { - *windowId = AddWindow(&sWindowTemplate_PromptYesOrNo_Width20); - } + *windowId = AddWindow(&sWindowTemplate_YesNoMsg); FillWindowPixelBuffer(*windowId, 0x11); AddTextPrinterParameterized4(*windowId, FONT_2, 0, 2, 0, 2, sMG_Ereader_TextColor_2, 0, gStringVar4); DrawTextBorderOuter(*windowId, 0x001, 0x0F); @@ -675,21 +668,19 @@ s8 DoMysteryGiftYesNo(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, c (*textState)++; break; case 1: + // Create Yes/No windowTemplate = sWindowTemplate_YesNoBox; if (yesNoBoxPlacement == 0) - { windowTemplate.tilemapTop = 9; - } else - { windowTemplate.tilemapTop = 15; - } CreateYesNoMenu(&windowTemplate, FONT_2, 0, 2, 10, 14, 0); (*textState)++; break; case 2: + // Handle Yes/No input input = Menu_ProcessInputNoWrapClearOnChoose(); - if (input == -1 || input == 0 || input == 1) + if (input == MENU_B_PRESSED || input == 0 || input == 1) { *textState = 0; rbox_fill_rectangle(*windowId); @@ -705,13 +696,14 @@ s8 DoMysteryGiftYesNo(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, c ClearWindowTilemap(*windowId); CopyWindowToVram(*windowId, COPYWIN_MAP); RemoveWindow(*windowId); - return -1; + return MENU_B_PRESSED; } - return -2; + return MENU_NOTHING_CHOSEN; } -s32 HandleMysteryGiftListMenu(u8 * textState, u16 * windowId, bool32 cannotToss, bool32 cannotSend) +// Handle the "Receive/Send/Toss" menu that appears when selecting Wonder Card/News +static s32 HandleMysteryGiftListMenu(u8 * textState, u16 * windowId, bool32 cannotToss, bool32 cannotSend) { struct WindowTemplate windowTemplate; s32 input; @@ -719,15 +711,12 @@ s32 HandleMysteryGiftListMenu(u8 * textState, u16 * windowId, bool32 cannotToss, switch (*textState) { case 0: - if (cannotToss == 0) - { + // Print menu message + if (!cannotToss) StringExpandPlaceholders(gStringVar4, gText_WhatToDoWithCards); - } else - { StringExpandPlaceholders(gStringVar4, gText_WhatToDoWithNews); - } - *windowId = AddWindow(&sMysteryGiftMenuWindowTemplate); + *windowId = AddWindow(&sWindowTemplate_GiftSelect); FillWindowPixelBuffer(*windowId, 0x11); AddTextPrinterParameterized4(*windowId, FONT_2, 0, 2, 0, 2, sMG_Ereader_TextColor_2, 0, gStringVar4); DrawTextBorderOuter(*windowId, 0x001, 0x0F); @@ -739,27 +728,19 @@ s32 HandleMysteryGiftListMenu(u8 * textState, u16 * windowId, bool32 cannotToss, windowTemplate = sWindowTemplate_YesNoBox; if (cannotSend) { - if (cannotToss == 0) - { - input = DoMysteryGiftListMenu(&sWindowTemplate_7by6, &sListMenu_ReceiveToss, 1, 0x00A, 0xE0); - } + if (!cannotToss) + input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_2Options, &sListMenu_ReceiveToss, 1, 0x00A, 0xE0); else - { - input = DoMysteryGiftListMenu(&sWindowTemplate_7by4, &sListMenu_Receive, 1, 0x00A, 0xE0); - } + input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_1Option, &sListMenu_Receive, 1, 0x00A, 0xE0); } else { - if (cannotToss == 0) - { - input = DoMysteryGiftListMenu(&sWindowTemplate_7by8, &sListMenu_ReceiveSendToss, 1, 0x00A, 0xE0); - } + if (!cannotToss) + input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_3Options, &sListMenu_ReceiveSendToss, 1, 0x00A, 0xE0); else - { - input = DoMysteryGiftListMenu(&sWindowTemplate_7by6, &sListMenu_ReceiveSend, 1, 0x00A, 0xE0); - } + input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_2Options, &sListMenu_ReceiveSend, 1, 0x00A, 0xE0); } - if (input != -1) + if (input != LIST_NOTHING_CHOSEN) { *textState = 0; rbox_fill_rectangle(*windowId); @@ -775,58 +756,42 @@ s32 HandleMysteryGiftListMenu(u8 * textState, u16 * windowId, bool32 cannotToss, ClearWindowTilemap(*windowId); CopyWindowToVram(*windowId, COPYWIN_MAP); RemoveWindow(*windowId); - return -2; + return LIST_CANCEL; } - return -1; + return LIST_NOTHING_CHOSEN; } -bool32 ValidateCardOrNews(bool32 cardOrNews) +static bool32 ValidateCardOrNews(bool32 isWonderNews) { - if (cardOrNews == 0) - { - return ValidateReceivedWonderCard(); - } + if (!isWonderNews) + return ValidateSavedWonderCard(); else - { - return ValidateReceivedWonderNews(); - } + return ValidateSavedWonderNews(); } -bool32 HandleLoadWonderCardOrNews(u8 * state, bool32 cardOrNews) +static bool32 HandleLoadWonderCardOrNews(u8 * state, bool32 isWonderNews) { - s32 v0; - switch (*state) { case 0: - if (cardOrNews == 0) - { - WonderCard_Init(GetSavedWonderCard(), sav1_get_mevent_buffer_2()); - } + if (!isWonderNews) + WonderCard_Init(GetSavedWonderCard(), GetSavedWonderCardMetadata()); else - { WonderNews_Init(GetSavedWonderNews()); - } (*state)++; break; case 1: - if (cardOrNews == 0) + if (!isWonderNews) { - v0 = WonderCard_Enter(); - check: - if (v0 != 0) - { - goto done; - } - break; + if (!WonderCard_Enter()) + return FALSE; } else { - v0 = WonderNews_Enter(); - goto check; + if (!WonderNews_Enter()) + return FALSE; } - done: *state = 0; return TRUE; } @@ -834,24 +799,20 @@ bool32 HandleLoadWonderCardOrNews(u8 * state, bool32 cardOrNews) return FALSE; } -bool32 DestroyNewsOrCard(bool32 cardOrNews) +static bool32 ClearSavedNewsOrCard(bool32 isWonderNews) { - if (cardOrNews == 0) - { - DestroyWonderCard(); - } + if (!isWonderNews) + ClearSavedWonderCardAndRelated(); else - { - DestroyWonderNews(); - } + ClearSavedWonderNewsAndRelated(); return TRUE; } -bool32 TearDownCardOrNews_ReturnToTopMenu(bool32 cardOrNews, bool32 arg1) +static bool32 ExitWonderCardOrNews(bool32 isWonderNews, bool32 useCancel) { - if (cardOrNews == 0) + if (!isWonderNews) { - if (WonderCard_Exit(arg1) != 0) + if (WonderCard_Exit(useCancel)) { WonderCard_Destroy(); return TRUE; @@ -863,7 +824,7 @@ bool32 TearDownCardOrNews_ReturnToTopMenu(bool32 cardOrNews, bool32 arg1) } else { - if (WonderNews_Exit(arg1) != 0) + if (WonderNews_Exit(useCancel)) { WonderNews_Destroy(); return TRUE; @@ -875,23 +836,23 @@ bool32 TearDownCardOrNews_ReturnToTopMenu(bool32 cardOrNews, bool32 arg1) } } -s32 mevent_message_prompt_discard(u8 * textState, u16 * windowId, bool32 cardOrNews) +static s32 AskDiscardGift(u8 * textState, u16 * windowId, bool32 isWonderNews) { - if (cardOrNews == 0) + if (!isWonderNews) return DoMysteryGiftYesNo(textState, windowId, TRUE, gText_IfThrowAwayCardEventWontHappen); else return DoMysteryGiftYesNo(textState, windowId, TRUE, gText_OkayToDiscardNews); } -bool32 mevent_message_was_thrown_away(u8 * textState, bool32 cardOrNews) +static bool32 PrintThrownAway(u8 * textState, bool32 isWonderNews) { - if (cardOrNews == 0) + if (!isWonderNews) return PrintMysteryGiftMenuMessage(textState, gText_WonderCardThrownAway); else return PrintMysteryGiftMenuMessage(textState, gText_WonderNewsThrownAway); } -bool32 mevent_save_game(u8 * state) +static bool32 SaveOnMysteryGiftMenu(u8 * state) { switch (*state) { @@ -909,9 +870,7 @@ bool32 mevent_save_game(u8 * state) break; case 3: if (JOY_NEW(A_BUTTON | B_BUTTON)) - { (*state)++; - } break; case 4: *state = 0; @@ -922,94 +881,92 @@ bool32 mevent_save_game(u8 * state) return FALSE; } -const u8 * mevent_message(u32 * flag_p, u8 cardOrNews, u8 cardOrNewsSource, u32 msgId) +static const u8 * GetClientResultMessage(bool32 * successMsg, bool8 isWonderNews, bool8 sourceIsFriend, u32 msgId) { const u8 * msg = NULL; - *flag_p = 0; + *successMsg = FALSE; switch (msgId) { - case 0: - *flag_p = 0; + case CLI_MSG_NOTHING_SENT: + *successMsg = FALSE; msg = gText_NothingSentOver; break; - case 1: - *flag_p = 0; + case CLI_MSG_RECORD_UPLOADED: + *successMsg = FALSE; msg = gText_RecordUploadedViaWireless; break; - case 2: - *flag_p = 1; - msg = cardOrNewsSource == 0 ? gText_WonderCardReceived : gText_WonderCardReceivedFrom; + case CLI_MSG_CARD_RECEIVED: + *successMsg = TRUE; + msg = !sourceIsFriend ? gText_WonderCardReceived : gText_WonderCardReceivedFrom; break; - case 3: - *flag_p = 1; - msg = cardOrNewsSource == 0 ? gText_WonderNewsReceived : gText_WonderNewsReceivedFrom; + case CLI_MSG_NEWS_RECEIVED: + *successMsg = TRUE; + msg = !sourceIsFriend ? gText_WonderNewsReceived : gText_WonderNewsReceivedFrom; break; - case 4: - *flag_p = 1; + case CLI_MSG_STAMP_RECEIVED: + *successMsg = TRUE; msg = gText_NewStampReceived; break; - case 5: - *flag_p = 0; + case CLI_MSG_HAD_CARD: + *successMsg = FALSE; msg = gText_AlreadyHadCard; break; - case 6: - *flag_p = 0; + case CLI_MSG_HAD_STAMP: + *successMsg = FALSE; msg = gText_AlreadyHadStamp; break; - case 7: - *flag_p = 0; + case CLI_MSG_HAD_NEWS: + *successMsg = FALSE; msg = gText_AlreadyHadNews; break; - case 8: - *flag_p = 0; + case CLI_MSG_NO_ROOM_STAMPS: + *successMsg = FALSE; msg = gText_NoMoreRoomForStamps; break; - case 9: - *flag_p = 0; + case CLI_MSG_COMM_CANCELED: + *successMsg = FALSE; msg = gText_CommunicationCanceled; break; - case 10: - *flag_p = 0; - msg = cardOrNews == 0 ? gText_CantAcceptCardFromTrainer : gText_CantAcceptNewsFromTrainer; + case CLI_MSG_CANT_ACCEPT: + *successMsg = FALSE; + msg = !isWonderNews ? gText_CantAcceptCardFromTrainer : gText_CantAcceptNewsFromTrainer; break; - case 11: - *flag_p = 0; + case CLI_MSG_COMM_ERROR: + *successMsg = FALSE; msg = gText_CommunicationError; break; - case 12: - *flag_p = 1; + case CLI_MSG_TRAINER_RECEIVED: + *successMsg = TRUE; msg = gText_NewTrainerReceived; break; - case 13: - *flag_p = 1; + case CLI_MSG_BUFFER_SUCCESS: + *successMsg = TRUE; + // msg is NULL, use buffer break; - case 14: - *flag_p = 0; + case CLI_MSG_BUFFER_FAILURE: + *successMsg = FALSE; + // msg is NULL, use buffer break; } return msg; } -bool32 PrintMGSuccessMessage(u8 * state, const u8 * arg1, u16 * arg2) +static bool32 PrintSuccessMessage(u8 * state, const u8 * msg, u16 * timer) { switch (*state) { case 0: - if (arg1 != NULL) - { - AddTextPrinterToWindow1(arg1); - } + if (msg != NULL) + AddTextPrinterToWindow1(msg); PlayFanfare(MUS_OBTAIN_ITEM); - *arg2 = 0; + *timer = 0; (*state)++; break; case 1: - if (++(*arg2) > 0xF0) - { + if (++(*timer) > 240) (*state)++; - } break; case 2: if (IsFanfareTaskInactive()) @@ -1023,632 +980,623 @@ bool32 PrintMGSuccessMessage(u8 * state, const u8 * arg1, u16 * arg2) return FALSE; } -const u8 * mevent_message_stamp_card_etc_send_status(u32 * a0, u8 unused, u32 msgId) +static const u8 * GetServerResultMessage(bool32 * wonderSuccess, u8 unused, u32 msgId) { const u8 * result = gText_CommunicationError; - *a0 = 0; + *wonderSuccess = FALSE; switch (msgId) { - case 0: + case SVR_MSG_NOTHING_SENT: result = gText_NothingSentOver; break; - case 1: + case SVR_MSG_RECORD_UPLOADED: result = gText_RecordUploadedViaWireless; break; - case 2: + case SVR_MSG_CARD_SENT: result = gText_WonderCardSentTo; - *a0 = 1; + *wonderSuccess = TRUE; break; - case 3: + case SVR_MSG_NEWS_SENT: result = gText_WonderNewsSentTo; - *a0 = 1; + *wonderSuccess = TRUE; break; - case 4: + case SVR_MSG_STAMP_SENT: result = gText_StampSentTo; break; - case 5: + case SVR_MSG_HAS_CARD: result = gText_OtherTrainerHasCard; break; - case 6: + case SVR_MSG_HAS_STAMP: result = gText_OtherTrainerHasStamp; break; - case 7: + case SVR_MSG_HAS_NEWS: result = gText_OtherTrainerHasNews; break; - case 8: + case SVR_MSG_NO_ROOM_STAMPS: result = gText_NoMoreRoomForStamps; break; - case 9: + case SVR_MSG_CLIENT_CANCELED: result = gText_OtherTrainerCanceled; break; - case 10: + case SVR_MSG_CANT_SEND_GIFT_1: result = gText_CantSendGiftToTrainer; break; - case 11: + case SVR_MSG_COMM_ERROR: result = gText_CommunicationError; break; - case 12: + case SVR_MSG_GIFT_SENT_1: result = gText_GiftSentTo; break; - case 13: + case SVR_MSG_GIFT_SENT_2: result = gText_GiftSentTo; break; - case 14: + case SVR_MSG_CANT_SEND_GIFT_2: result = gText_CantSendGiftToTrainer; break; } return result; } -static bool32 PrintMGSendStatus(u8 * state, u16 * arg1, u8 arg2, u32 msgId) +static bool32 PrintServerResultMessage(u8 * state, u16 * timer, bool8 sourceIsFriend, u32 msgId) { - u32 flag; - const u8 * str = mevent_message_stamp_card_etc_send_status(&flag, arg2, msgId); - if (flag) - { - return PrintMGSuccessMessage(state, str, arg1); - } + bool32 wonderSuccess; + const u8 * str = GetServerResultMessage(&wonderSuccess, sourceIsFriend, msgId); + if (wonderSuccess) + return PrintSuccessMessage(state, str, timer); else - { return PrintMysteryGiftMenuMessage(state, str); - } } -void task_add_00_mystery_gift(void) +// States for Task_MysteryGift. +// CLIENT states are for when the player is receiving a gift, and use mystery_gift_client.c link functions. +// SERVER states are for when the player is sending a gift, and use mystery_gift_server.c link functions. +// Other states handle the general Mystery Gift menu usage. +enum { + MG_STATE_TO_MAIN_MENU, + MG_STATE_MAIN_MENU, + MG_STATE_DONT_HAVE_ANY, + MG_STATE_SOURCE_PROMPT, + MG_STATE_SOURCE_PROMPT_INPUT, + MG_STATE_CLIENT_LINK_START, + MG_STATE_CLIENT_LINK_WAIT, + MG_STATE_CLIENT_COMMUNICATING, + MG_STATE_CLIENT_LINK, + MG_STATE_CLIENT_YES_NO, + MG_STATE_CLIENT_MESSAGE, + MG_STATE_CLIENT_ASK_TOSS, + MG_STATE_CLIENT_ASK_TOSS_UNRECEIVED, + MG_STATE_CLIENT_LINK_END, + MG_STATE_CLIENT_COMM_COMPLETED, + MG_STATE_CLIENT_RESULT_MSG, + MG_STATE_CLIENT_ERROR, + MG_STATE_SAVE_LOAD_GIFT, + MG_STATE_LOAD_GIFT, + MG_STATE_UNUSED, + MG_STATE_HANDLE_GIFT_INPUT, + MG_STATE_HANDLE_GIFT_SELECT, + MG_STATE_ASK_TOSS, + MG_STATE_ASK_TOSS_UNRECEIVED, + MG_STATE_TOSS, + MG_STATE_TOSS_SAVE, + MG_STATE_TOSSED, + MG_STATE_GIFT_INPUT_EXIT, + MG_STATE_RECEIVE, + MG_STATE_SEND, + MG_STATE_SERVER_LINK_WAIT, + MG_STATE_SERVER_LINK_START, + MG_STATE_SERVER_LINK, + MG_STATE_SERVER_LINK_END, + MG_STATE_SERVER_LINK_END_WAIT, + MG_STATE_SERVER_RESULT_MSG, + MG_STATE_SERVER_ERROR, + MG_STATE_EXIT, +}; + +static void CreateMysteryGiftTask(void) { - u8 taskId = CreateTask(task00_mystery_gift, 0); + u8 taskId = CreateTask(Task_MysteryGift, 0); struct MysteryGiftTaskData * data = (void *)gTasks[taskId].data; - data->state = 0; + data->state = MG_STATE_TO_MAIN_MENU; data->textState = 0; - data->unkA = 0; - data->unkB = 0; - data->IsCardOrNews = 0; - data->source = 0; - data->curPromptWindowId = 0; - data->unk2 = 0; - data->unk4 = 0; - data->unk6 = 0; - data->prevPromptWindowId = 0; - data->buffer = AllocZeroed(0x40); + data->unused4 = 0; + data->unused5 = 0; + data->isWonderNews = FALSE; + data->sourceIsFriend = FALSE; + data->var = 0; + data->unused1 = 0; + data->unused2 = 0; + data->unused3 = 0; + data->msgId = 0; + data->clientMsg = AllocZeroed(CLIENT_MAX_MSG_SIZE); } -void task00_mystery_gift(u8 taskId) +static void Task_MysteryGift(u8 taskId) { struct MysteryGiftTaskData * data = (void *)gTasks[taskId].data; - u32 sp0, flag; - const u8 * r1; + bool32 successMsg, input; + const u8 * msg; switch (data->state) { - case 0: - data->state = 1; + case MG_STATE_TO_MAIN_MENU: + data->state = MG_STATE_MAIN_MENU; break; - case 1: - switch (MysteryGift_HandleThreeOptionMenu(&data->textState, &data->curPromptWindowId, FALSE)) + case MG_STATE_MAIN_MENU: + // Main Mystery Gift menu, player can select Wonder Cards or News (or exit) + switch (MysteryGift_HandleThreeOptionMenu(&data->textState, &data->var, FALSE)) { - case 0: - data->IsCardOrNews = 0; - if (ValidateReceivedWonderCard() == TRUE) - { - data->state = 18; - } + case 0: // "Wonder Cards" + data->isWonderNews = FALSE; + if (ValidateSavedWonderCard() == TRUE) + data->state = MG_STATE_LOAD_GIFT; else - { - data->state = 2; - } + data->state = MG_STATE_DONT_HAVE_ANY; break; - case 1: - data->IsCardOrNews = 1; - if (ValidateReceivedWonderNews() == TRUE) - { - data->state = 18; - } + case 1: // "Wonder News" + data->isWonderNews = TRUE; + if (ValidateSavedWonderNews() == TRUE) + data->state = MG_STATE_LOAD_GIFT; else - { - data->state = 2; - } + data->state = MG_STATE_DONT_HAVE_ANY; break; - case -2u: - data->state = 37; + case LIST_CANCEL: + data->state = MG_STATE_EXIT; break; } break; - case 2: + case MG_STATE_DONT_HAVE_ANY: { - if (data->IsCardOrNews == 0) + // Player doesn't have any Wonder Card/News + // Start prompt to ask where to read one from + if (!data->isWonderNews) { if (PrintMysteryGiftMenuMessage(&data->textState, gText_DontHaveCardNewOneInput)) { - data->state = 3; - PrintMysteryGiftOrEReaderTopMenu(0, 1); + data->state = MG_STATE_SOURCE_PROMPT; + PrintMysteryGiftOrEReaderTopMenu(FALSE, TRUE); } } else { if (PrintMysteryGiftMenuMessage(&data->textState, gText_DontHaveNewsNewOneInput)) { - data->state = 3; - PrintMysteryGiftOrEReaderTopMenu(0, 1); + data->state = MG_STATE_SOURCE_PROMPT; + PrintMysteryGiftOrEReaderTopMenu(FALSE, TRUE); } } break; } - case 3: - if (data->IsCardOrNews == 0) - { + case MG_STATE_SOURCE_PROMPT: + if (!data->isWonderNews) AddTextPrinterToWindow1(gText_WhereShouldCardBeAccessed); - } else - { AddTextPrinterToWindow1(gText_WhereShouldNewsBeAccessed); - } - data->state = 4; + data->state = MG_STATE_SOURCE_PROMPT_INPUT; break; - case 4: - switch (MysteryGift_HandleThreeOptionMenu(&data->textState, &data->curPromptWindowId, TRUE)) + case MG_STATE_SOURCE_PROMPT_INPUT: + // Choose where to access the Wonder Card/News from + switch (MysteryGift_HandleThreeOptionMenu(&data->textState, &data->var, TRUE)) { - case 0: + case 0: // "Wireless Communication" ClearTextWindow(); - data->state = 5; - data->source = 0; + data->state = MG_STATE_CLIENT_LINK_START; + data->sourceIsFriend = FALSE; break; - case 1: + case 1: // "Friend" ClearTextWindow(); - data->state = 5; - data->source = 1; + data->state = MG_STATE_CLIENT_LINK_START; + data->sourceIsFriend = TRUE; break; - case -2u: + case LIST_CANCEL: ClearTextWindow(); - if (ValidateCardOrNews(data->IsCardOrNews)) + if (ValidateCardOrNews(data->isWonderNews)) { - data->state = 18; + data->state = MG_STATE_LOAD_GIFT; } else { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); } break; } break; - case 5: + case MG_STATE_CLIENT_LINK_START: *gStringVar1 = EOS; *gStringVar2 = EOS; *gStringVar3 = EOS; - switch (data->IsCardOrNews) + switch (data->isWonderNews) { - case 0: - if (data->source == 1) + case FALSE: + if (data->sourceIsFriend == TRUE) CreateTask_LinkMysteryGiftWithFriend(ACTIVITY_WONDER_CARD); - else if (data->source == 0) + else if (data->sourceIsFriend == FALSE) CreateTask_LinkMysteryGiftOverWireless(ACTIVITY_WONDER_CARD); break; - case 1: - if (data->source == 1) + case TRUE: + if (data->sourceIsFriend == TRUE) CreateTask_LinkMysteryGiftWithFriend(ACTIVITY_WONDER_NEWS); - else if (data->source == 0) + else if (data->sourceIsFriend == FALSE) CreateTask_LinkMysteryGiftOverWireless(ACTIVITY_WONDER_NEWS); break; } - data->state = 6; + data->state = MG_STATE_CLIENT_LINK_WAIT; break; - case 6: + case MG_STATE_CLIENT_LINK_WAIT: if (gReceivedRemoteLinkPlayers) { ClearScreenInBg0(TRUE); - data->state = 7; - mevent_client_do_init(); + data->state = MG_STATE_CLIENT_COMMUNICATING; + MysteryGiftClient_Create(); } - else if (gSpecialVar_Result == 5) + else if (gSpecialVar_Result == LINKUP_FAILED) { + // Link failed, return to link start menu ClearScreenInBg0(TRUE); - data->state = 3; + data->state = MG_STATE_SOURCE_PROMPT; } break; - case 7: + case MG_STATE_CLIENT_COMMUNICATING: AddTextPrinterToWindow1(gText_Communicating); - data->state = 8; + data->state = MG_STATE_CLIENT_LINK; break; - case 8: - switch (mevent_client_do_exec(&data->curPromptWindowId)) + case MG_STATE_CLIENT_LINK: + switch (MysteryGiftClient_Run(&data->var)) { - case 6: // done + case CLI_RET_END: Rfu_SetCloseLinkCallback(); - data->prevPromptWindowId = data->curPromptWindowId; - data->state = 13; + data->msgId = data->var; + data->state = MG_STATE_CLIENT_LINK_END; break; - case 5: - memcpy(data->buffer, mevent_client_get_buffer(), 0x40); - mevent_client_inc_flag(); + case CLI_RET_COPY_MSG: + memcpy(data->clientMsg, MysteryGiftClient_GetMsg(), CLIENT_MAX_MSG_SIZE); + MysteryGiftClient_AdvanceState(); break; - case 3: - data->state = 10; + case CLI_RET_PRINT_MSG: + data->state = MG_STATE_CLIENT_MESSAGE; break; - case 2: - data->state = 9; + case CLI_RET_YES_NO: + data->state = MG_STATE_CLIENT_YES_NO; break; - case 4: - data->state = 11; + case CLI_RET_ASK_TOSS: + data->state = MG_STATE_CLIENT_ASK_TOSS; StringCopy(gStringVar1, gLinkPlayers[0].name); break; } break; - case 9: - flag = DoMysteryGiftYesNo(&data->textState, &data->curPromptWindowId, FALSE, mevent_client_get_buffer()); - switch (flag) + case MG_STATE_CLIENT_YES_NO: + input = DoMysteryGiftYesNo(&data->textState, &data->var, FALSE, MysteryGiftClient_GetMsg()); + switch (input) { - case 0: - mevent_client_set_param(0); - mevent_client_inc_flag(); - data->state = 7; + case 0: // Yes + MysteryGiftClient_SetParam(FALSE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; break; - case 1: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; - break; - case -1u: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; + case 1: // No + case MENU_B_PRESSED: + MysteryGiftClient_SetParam(TRUE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; break; } break; - case 10: - if (PrintMysteryGiftMenuMessage(&data->textState, mevent_client_get_buffer())) + case MG_STATE_CLIENT_MESSAGE: + if (PrintMysteryGiftMenuMessage(&data->textState, MysteryGiftClient_GetMsg())) { - mevent_client_inc_flag(); - data->state = 7; + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; } break; - case 11: - flag = DoMysteryGiftYesNo(&data->textState, &data->curPromptWindowId, FALSE, gText_ThrowAwayWonderCard); - switch (flag) + case MG_STATE_CLIENT_ASK_TOSS: + // Player is receiving a new Wonder Card/News but needs to toss an existing one to make room. + // Ask for confirmation. + input = DoMysteryGiftYesNo(&data->textState, &data->var, FALSE, gText_ThrowAwayWonderCard); + switch (input) { - case 0: - if (CheckReceivedGiftFromWonderCard() == TRUE) + case 0: // Yes + if (IsSavedWonderCardGiftNotReceived() == TRUE) { - data->state = 12; + data->state = MG_STATE_CLIENT_ASK_TOSS_UNRECEIVED; } else { - mevent_client_set_param(0); - mevent_client_inc_flag(); - data->state = 7; + MysteryGiftClient_SetParam(FALSE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; } break; - case 1: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; - break; - case -1u: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; + case 1: // No + case MENU_B_PRESSED: + MysteryGiftClient_SetParam(TRUE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; break; } break; - case 12: - flag = DoMysteryGiftYesNo(&data->textState, &data->curPromptWindowId, FALSE, gText_HaventReceivedCardsGift); - switch (flag) + case MG_STATE_CLIENT_ASK_TOSS_UNRECEIVED: + // Player has selected to toss a Wonder Card that they haven't received the gift for. + // Ask for confirmation again. + input = DoMysteryGiftYesNo(&data->textState, &data->var, FALSE, gText_HaventReceivedCardsGift); + switch (input) { - case 0: - mevent_client_set_param(0); - mevent_client_inc_flag(); - data->state = 7; + case 0: // Yes + MysteryGiftClient_SetParam(FALSE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; break; - case 1: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; - break; - case -1u: - mevent_client_set_param(1); - mevent_client_inc_flag(); - data->state = 7; + case 1: // No + case MENU_B_PRESSED: + MysteryGiftClient_SetParam(TRUE); + MysteryGiftClient_AdvanceState(); + data->state = MG_STATE_CLIENT_COMMUNICATING; break; } break; - case 13: + case MG_STATE_CLIENT_LINK_END: if (IsLinkRfuTaskFinished()) { DestroyWirelessStatusIndicatorSprite(); - data->state = 14; + data->state = MG_STATE_CLIENT_COMM_COMPLETED; } break; - case 14: + case MG_STATE_CLIENT_COMM_COMPLETED: if (PrintStringAndWait2Seconds(&data->textState, gText_CommunicationCompleted)) { - if (data->source == 1) - { + if (data->sourceIsFriend == TRUE) StringCopy(gStringVar1, gLinkPlayers[0].name); - } - data->state = 15; + data->state = MG_STATE_CLIENT_RESULT_MSG; } break; - case 15: - r1 = mevent_message(&sp0, data->IsCardOrNews, data->source, data->prevPromptWindowId); - if (r1 == NULL) - r1 = data->buffer; - if (sp0) - flag = PrintMGSuccessMessage(&data->textState, r1, &data->curPromptWindowId); + case MG_STATE_CLIENT_RESULT_MSG: + msg = GetClientResultMessage(&successMsg, data->isWonderNews, data->sourceIsFriend, data->msgId); + if (msg == NULL) + msg = data->clientMsg; + if (successMsg) + input = PrintSuccessMessage(&data->textState, msg, &data->var); else - flag = PrintMysteryGiftMenuMessage(&data->textState, r1); + input = PrintMysteryGiftMenuMessage(&data->textState, msg); - if (flag) + // input var re-used, here it is TRUE if the message is finished + if (input) { - if (data->prevPromptWindowId == 3) + if (data->msgId == CLI_MSG_NEWS_RECEIVED) { - if (data->source == 1) - { - MENewsJisan_SetRandomReward(1); - } + if (data->sourceIsFriend == TRUE) + WonderNews_SetReward(WONDER_NEWS_RECV_FRIEND); else - { - MENewsJisan_SetRandomReward(2); - } + WonderNews_SetReward(WONDER_NEWS_RECV_WIRELESS); } - if (sp0 == 0) + if (!successMsg) { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); + // Did not receive card/news, return to main menu + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); } else { - data->state = 17; + data->state = MG_STATE_SAVE_LOAD_GIFT; } } break; - case 16: - if (PrintMysteryGiftMenuMessage(&data->textState, gText_CommunicationError)) + case MG_STATE_SAVE_LOAD_GIFT: + if (SaveOnMysteryGiftMenu(&data->textState)) { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); } break; - case 17: - if (mevent_save_game(&data->textState)) - { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); - } + case MG_STATE_LOAD_GIFT: + if (HandleLoadWonderCardOrNews(&data->textState, data->isWonderNews)) + data->state = MG_STATE_HANDLE_GIFT_INPUT; break; - case 18: - if (HandleLoadWonderCardOrNews(&data->textState, data->IsCardOrNews)) - { - data->state = 20; - } - break; - case 20: - if (data->IsCardOrNews == 0) + case MG_STATE_HANDLE_GIFT_INPUT: + if (!data->isWonderNews) { + // Handle Wonder Card input if (JOY_NEW(A_BUTTON)) - { - data->state = 21; - } + data->state = MG_STATE_HANDLE_GIFT_SELECT; if (JOY_NEW(B_BUTTON)) - { - data->state = 27; - } + data->state = MG_STATE_GIFT_INPUT_EXIT; } else { switch (WonderNews_GetInput(gMain.newKeys)) { - case 0: + case NEWS_INPUT_A: WonderNews_RemoveScrollIndicatorArrowPair(); - data->state = 21; + data->state = MG_STATE_HANDLE_GIFT_SELECT; break; - case 1: - data->state = 27; + case NEWS_INPUT_B: + data->state = MG_STATE_GIFT_INPUT_EXIT; break; } } break; - case 21: + case MG_STATE_HANDLE_GIFT_SELECT: { + // A Wonder Card/News has been selected, handle its menu u32 result; - if (data->IsCardOrNews == 0) + if (!data->isWonderNews) { - if (WonderCard_Test_Unk_08_6()) - { - result = HandleMysteryGiftListMenu(&data->textState, &data->curPromptWindowId, data->IsCardOrNews, FALSE); - } + if (IsSendingSavedWonderCardAllowed()) + result = HandleMysteryGiftListMenu(&data->textState, &data->var, data->isWonderNews, FALSE); else - { - result = HandleMysteryGiftListMenu(&data->textState, &data->curPromptWindowId, data->IsCardOrNews, TRUE); - } + result = HandleMysteryGiftListMenu(&data->textState, &data->var, data->isWonderNews, TRUE); } else { - if (WonderNews_Test_Unk_02()) - { - result = HandleMysteryGiftListMenu(&data->textState, &data->curPromptWindowId, data->IsCardOrNews, FALSE); - } + if (IsSendingSavedWonderNewsAllowed()) + result = HandleMysteryGiftListMenu(&data->textState, &data->var, data->isWonderNews, FALSE); else - { - result = HandleMysteryGiftListMenu(&data->textState, &data->curPromptWindowId, data->IsCardOrNews, TRUE); - } + result = HandleMysteryGiftListMenu(&data->textState, &data->var, data->isWonderNews, TRUE); } switch (result) { - case 0: - data->state = 28; + case 0: // Receive + data->state = MG_STATE_RECEIVE; break; - case 1: - data->state = 29; + case 1: // Send + data->state = MG_STATE_SEND; break; - case 2: - data->state = 22; + case 2: // Toss + data->state = MG_STATE_ASK_TOSS; break; - case -2u: - if (data->IsCardOrNews == 1) - { + case LIST_CANCEL: + if (data->isWonderNews == TRUE) WonderNews_AddScrollIndicatorArrowPair(); - } - data->state = 20; + data->state = MG_STATE_HANDLE_GIFT_INPUT; break; } break; } - case 22: - switch (mevent_message_prompt_discard(&data->textState, &data->curPromptWindowId, data->IsCardOrNews)) + case MG_STATE_ASK_TOSS: + // Player is attempting to discard a saved Wonder Card/News + switch (AskDiscardGift(&data->textState, &data->var, data->isWonderNews)) { - case 0: - if (data->IsCardOrNews == 0 && CheckReceivedGiftFromWonderCard() == TRUE) - { - data->state = 23; - } + case 0: // Yes + if (!data->isWonderNews && IsSavedWonderCardGiftNotReceived() == TRUE) + data->state = MG_STATE_ASK_TOSS_UNRECEIVED; else + data->state = MG_STATE_TOSS; + break; + case 1: // No + case MENU_B_PRESSED: + data->state = MG_STATE_HANDLE_GIFT_SELECT; + break; + } + break; + case MG_STATE_ASK_TOSS_UNRECEIVED: + // Player has selected to toss a Wonder Card that they haven't received the gift for. + // Ask for confirmation again. + switch ((u32)DoMysteryGiftYesNo(&data->textState, &data->var, TRUE, gText_HaventReceivedGiftOkayToDiscard)) + { + case 0: // Yes + data->state = MG_STATE_TOSS; + break; + case 1: // No + case MENU_B_PRESSED: + data->state = MG_STATE_HANDLE_GIFT_SELECT; + break; + } + break; + case MG_STATE_TOSS: + if (ExitWonderCardOrNews(data->isWonderNews, TRUE)) + { + ClearSavedNewsOrCard(data->isWonderNews); + data->state = MG_STATE_TOSS_SAVE; + } + break; + case MG_STATE_TOSS_SAVE: + if (SaveOnMysteryGiftMenu(&data->textState)) + data->state = MG_STATE_TOSSED; + break; + case MG_STATE_TOSSED: + if (PrintThrownAway(&data->textState, data->isWonderNews)) + { + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); + } + break; + case MG_STATE_GIFT_INPUT_EXIT: + if (ExitWonderCardOrNews(data->isWonderNews, FALSE)) + data->state = MG_STATE_TO_MAIN_MENU; + break; + case MG_STATE_RECEIVE: + if (ExitWonderCardOrNews(data->isWonderNews, TRUE)) + data->state = MG_STATE_SOURCE_PROMPT; + break; + case MG_STATE_SEND: + if (ExitWonderCardOrNews(data->isWonderNews, TRUE)) + { + switch (data->isWonderNews) { - data->state = 24; - } - break; - case 1: - data->state = 21; - break; - case -1: - data->state = 21; - break; - } - break; - case 23: - switch ((u32)DoMysteryGiftYesNo(&data->textState, &data->curPromptWindowId, TRUE, gText_HaventReceivedGiftOkayToDiscard)) - { - case 0: - data->state = 24; - break; - case 1: - data->state = 21; - break; - case -1u: - data->state = 21; - break; - } - break; - case 24: - if (TearDownCardOrNews_ReturnToTopMenu(data->IsCardOrNews, 1)) - { - DestroyNewsOrCard(data->IsCardOrNews); - data->state = 25; - } - break; - case 25: - if (mevent_save_game(&data->textState)) - { - data->state = 26; - } - break; - case 26: - if (mevent_message_was_thrown_away(&data->textState, data->IsCardOrNews)) - { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); - } - break; - case 27: - if (TearDownCardOrNews_ReturnToTopMenu(data->IsCardOrNews, 0)) - { - data->state = 0; - } - break; - case 28: - if (TearDownCardOrNews_ReturnToTopMenu(data->IsCardOrNews, 1)) - { - data->state = 3; - } - break; - case 29: - if (TearDownCardOrNews_ReturnToTopMenu(data->IsCardOrNews, 1)) - { - switch (data->IsCardOrNews) - { - case 0: + case FALSE: CreateTask_SendMysteryGift(ACTIVITY_WONDER_CARD); break; - case 1: + case TRUE: CreateTask_SendMysteryGift(ACTIVITY_WONDER_NEWS); break; } - data->source = 1; - data->state = 30; + data->sourceIsFriend = TRUE; + data->state = MG_STATE_SERVER_LINK_WAIT; } break; - case 30: + case MG_STATE_SERVER_LINK_WAIT: if (gReceivedRemoteLinkPlayers) { - ClearScreenInBg0(1); - data->state = 31; + ClearScreenInBg0(TRUE); + data->state = MG_STATE_SERVER_LINK_START; } - else if (gSpecialVar_Result == 5) + else if (gSpecialVar_Result == LINKUP_FAILED) { - ClearScreenInBg0(1); - data->state = 18; + ClearScreenInBg0(TRUE); + data->state = MG_STATE_LOAD_GIFT; } break; - case 31: + case MG_STATE_SERVER_LINK_START: *gStringVar1 = EOS; *gStringVar2 = EOS; *gStringVar3 = EOS; - if (data->IsCardOrNews == 0) + if (!data->isWonderNews) { AddTextPrinterToWindow1(gText_SendingWonderCard); - mevent_srv_new_wcard(); + MysterGiftServer_CreateForCard(); } else { AddTextPrinterToWindow1(gText_SendingWonderNews); - mevent_srv_init_wnews(); + MysterGiftServer_CreateForNews(); } - data->state = 32; + data->state = MG_STATE_SERVER_LINK; break; - case 32: - if (mevent_srv_common_do_exec(&data->curPromptWindowId) == 3) + case MG_STATE_SERVER_LINK: + if (MysterGiftServer_Run(&data->var) == SVR_RET_END) { - data->prevPromptWindowId = data->curPromptWindowId; - data->state = 33; + data->msgId = data->var; + data->state = MG_STATE_SERVER_LINK_END; } break; - case 33: + case MG_STATE_SERVER_LINK_END: Rfu_SetCloseLinkCallback(); StringCopy(gStringVar1, gLinkPlayers[1].name); - data->state = 34; + data->state = MG_STATE_SERVER_LINK_END_WAIT; break; - case 34: + case MG_STATE_SERVER_LINK_END_WAIT: if (IsLinkRfuTaskFinished()) { DestroyWirelessStatusIndicatorSprite(); - data->state = 35; + data->state = MG_STATE_SERVER_RESULT_MSG; } break; - case 35: - if (PrintMGSendStatus(&data->textState, &data->curPromptWindowId, data->source, data->prevPromptWindowId)) + case MG_STATE_SERVER_RESULT_MSG: + if (PrintServerResultMessage(&data->textState, &data->var, data->sourceIsFriend, data->msgId)) { - if (data->source == 1 && data->prevPromptWindowId == 3) + if (data->sourceIsFriend == TRUE && data->msgId == SVR_MSG_NEWS_SENT) { - MENewsJisan_SetRandomReward(3); - data->state = 17; + WonderNews_SetReward(WONDER_NEWS_SENT); + data->state = MG_STATE_SAVE_LOAD_GIFT; } else { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); } } break; - case 36: + case MG_STATE_CLIENT_ERROR: + case MG_STATE_SERVER_ERROR: if (PrintMysteryGiftMenuMessage(&data->textState, gText_CommunicationError)) { - data->state = 0; - PrintMysteryGiftOrEReaderTopMenu(0, 0); + data->state = MG_STATE_TO_MAIN_MENU; + PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE); } break; - case 37: + case MG_STATE_EXIT: CloseLink(); HelpSystem_Enable(); - Free(data->buffer); + Free(data->clientMsg); DestroyTask(taskId); SetMainCallback2(MainCB_FreeAllBuffersAndReturnToInitTitleScreen); break; diff --git a/src/mystery_gift_scripts.c b/src/mystery_gift_scripts.c new file mode 100644 index 000000000..ef781c5af --- /dev/null +++ b/src/mystery_gift_scripts.c @@ -0,0 +1,198 @@ +#include "global.h" +#include "mystery_gift_server.h" +#include "mystery_gift_client.h" +#include "constants/mystery_gift.h" + +extern const struct MysteryGiftServerCmd gServerScript_ClientCanceledCard[]; + +// Unreferenced +static const u8 sText_CollectedAllStamps[] = _("You have collected all STAMPs!\nWant to input a CARD as a prize?"); + +//================== +// Client scripts +//================== + +const struct MysteryGiftClientCmd gMysteryGiftClientScript_Init[] = { + {CLI_RECV, MG_LINKID_CLIENT_SCRIPT}, + {CLI_COPY_RECV} +}; + +static const struct MysteryGiftClientCmd sClientScript_SendGameData[] = { + {CLI_LOAD_GAME_DATA}, + {CLI_SEND_LOADED}, + {CLI_RECV, MG_LINKID_CLIENT_SCRIPT}, + {CLI_COPY_RECV} +}; + +static const struct MysteryGiftClientCmd sClientScript_CantAccept[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_CANT_ACCEPT} +}; + +static const struct MysteryGiftClientCmd sClientScript_CommError[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_COMM_ERROR} +}; + +static const struct MysteryGiftClientCmd sClientScript_NothingSent[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_NOTHING_SENT} +}; + +static const struct MysteryGiftClientCmd sClientScript_SaveCard[] = { + {CLI_RECV, MG_LINKID_CARD}, + {CLI_SAVE_CARD}, + {CLI_RECV, MG_LINKID_RAM_SCRIPT}, + {CLI_SAVE_RAM_SCRIPT}, + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_CARD_RECEIVED} +}; + +static const struct MysteryGiftClientCmd sClientScript_SaveNews[] = { + {CLI_RECV, MG_LINKID_NEWS}, + {CLI_SAVE_NEWS}, + {CLI_SEND_LOADED}, // Send whether or not the News was saved (read by sServerScript_SendNews) + {CLI_RECV, MG_LINKID_CLIENT_SCRIPT}, + {CLI_COPY_RECV} +}; + +static const struct MysteryGiftClientCmd sClientScript_HadNews[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_HAD_NEWS} +}; + +static const struct MysteryGiftClientCmd sClientScript_NewsReceived[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_NEWS_RECEIVED} +}; + +static const struct MysteryGiftClientCmd sClientScript_AskToss[] = { + {CLI_ASK_TOSS}, + {CLI_LOAD_TOSS_RESPONSE}, + {CLI_SEND_LOADED}, + {CLI_RECV, MG_LINKID_CLIENT_SCRIPT}, + {CLI_COPY_RECV} +}; + +static const struct MysteryGiftClientCmd sClientScript_Canceled[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_COMM_CANCELED} +}; + +static const struct MysteryGiftClientCmd sClientScript_HadCard[] = { + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_HAD_CARD} +}; + +static const struct MysteryGiftClientCmd sClientScript_DynamicSuccess[] = { + {CLI_RECV, MG_LINKID_DYNAMIC_MSG}, + {CLI_COPY_MSG}, + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_BUFFER_SUCCESS} +}; + +//================== +// Server scripts +//================== + +static const struct MysteryGiftServerCmd sServerScript_CantSend[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_CantAccept)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_CANT_SEND_GIFT_1} +}; + +static const struct MysteryGiftServerCmd sServerScript_CommError[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_CommError)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_COMM_ERROR} +}; + +static const struct MysteryGiftServerCmd sServerScript_ClientCanceledNews[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_Canceled)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_CLIENT_CANCELED} +}; + +static const struct MysteryGiftServerCmd sServerScript_HasNews[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_HadNews)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_HAS_NEWS} +}; + +static const struct MysteryGiftServerCmd sServerScript_SendNews[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_SaveNews)}, + {SVR_SEND}, + {SVR_LOAD_NEWS}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_RESPONSE}, + {SVR_READ_RESPONSE}, + {SVR_GOTO_IF_EQ, TRUE, sServerScript_HasNews}, // Wonder News was not saved + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_NewsReceived)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_NEWS_SENT} +}; + +static const struct MysteryGiftServerCmd sServerScript_SendCard[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_SaveCard)}, + {SVR_SEND}, + {SVR_LOAD_CARD}, + {SVR_SEND}, + {SVR_LOAD_RAM_SCRIPT}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_CARD_SENT} +}; + +static const struct MysteryGiftServerCmd sServerScript_TossPrompt[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_AskToss)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_RESPONSE}, + {SVR_READ_RESPONSE}, + {SVR_GOTO_IF_EQ, FALSE, sServerScript_SendCard}, // Tossed old card, send new one + {SVR_GOTO, .ptr = gServerScript_ClientCanceledCard} // Kept old card, cancel new one +}; + +static const struct MysteryGiftServerCmd sServerScript_HasCard[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_HadCard)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_HAS_CARD} +}; + +static const struct MysteryGiftServerCmd sServerScript_NothingSent[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_NothingSent)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_NOTHING_SENT} +}; + +const struct MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderNews[] = { + {SVR_COPY_SAVED_NEWS}, + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_SendGameData)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_GAME_DATA}, + {SVR_COPY_GAME_DATA}, + {SVR_CHECK_GAME_DATA}, + {SVR_GOTO_IF_EQ, FALSE, sServerScript_CantSend}, + {SVR_GOTO, .ptr = sServerScript_SendNews}, +}; + +const struct MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderCard[] = { + {SVR_COPY_SAVED_CARD}, + {SVR_COPY_SAVED_RAM_SCRIPT}, + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_SendGameData)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_GAME_DATA}, + {SVR_COPY_GAME_DATA}, + {SVR_CHECK_GAME_DATA}, + {SVR_GOTO_IF_EQ, FALSE, sServerScript_CantSend}, + {SVR_CHECK_EXISTING_CARD}, + {SVR_GOTO_IF_EQ, HAS_DIFF_CARD, sServerScript_TossPrompt}, + {SVR_GOTO_IF_EQ, HAS_NO_CARD, sServerScript_SendCard}, + {SVR_GOTO, .ptr = sServerScript_HasCard} // HAS_SAME_CARD +}; diff --git a/src/mystery_gift_server.c b/src/mystery_gift_server.c new file mode 100644 index 000000000..f3b2af2f5 --- /dev/null +++ b/src/mystery_gift_server.c @@ -0,0 +1,302 @@ +#include "global.h" +#include "gflib.h" +#include "script.h" +#include "mystery_gift.h" +#include "mystery_gift_server.h" + +// Assert statements use the original GF names, which are defined below. +// Note that their name "flag" is especially misleading, +// as it's not a boolean (for example it can contain a size argument). +// 'parameter' is shortened to param explicitly to avoid a collision with +// the original name for a different field. +#define mainseqno funcId +#define func_tbl sFuncTable +#define parameter ptr +#define flag param +#define ME_SEND_BUF_SIZE MG_LINK_BUFFER_SIZE +#define FILE ABSPATH("mevent_server.c") + +#define ASSERT_PTR_EMPTY(lineNum) AGB_ASSERT_EX(cmd->parameter == NULL, FILE, (lineNum)); +#define ASSERT_PARAM_EMPTY(lineNum) AGB_ASSERT_EX(cmd->flag == FALSE, FILE, (lineNum)); +#define ASSERT_PTR_PARAM_EMPTY(lineNum) AGB_ASSERT_EX(cmd->flag == FALSE && cmd->parameter == NULL, FILE, (lineNum)); +#define ASSERT_VALID_FUNC(lineNum) AGB_ASSERT_EX(svr->mainseqno < NELEMS(func_tbl), FILE, (lineNum)); +#define ASSERT_SIZE_OK(lineNum) AGB_ASSERT_EX(size <= ME_SEND_BUF_SIZE, FILE, (lineNum)); + +enum { + FUNC_INIT, + FUNC_DONE, + FUNC_RECV, + FUNC_SEND, + FUNC_RUN, +}; + +static EWRAM_DATA struct MysteryGiftServer * sServer = NULL; + +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 MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderNews[]; +extern const struct MysteryGiftServerCmd gMysteryGiftServerScript_SendWonderCard[]; + +void MysterGiftServer_CreateForNews(void) +{ + sServer = AllocZeroed(sizeof(*sServer)); + MysteryGiftServer_Init(sServer, gMysteryGiftServerScript_SendWonderNews, 0, 1); +} + +void MysterGiftServer_CreateForCard(void) +{ + sServer = AllocZeroed(sizeof(*sServer)); + MysteryGiftServer_Init(sServer, gMysteryGiftServerScript_SendWonderCard, 0, 1); +} + +u32 MysterGiftServer_Run(u16 * endVal) +{ + u32 result; + if (sServer == NULL) + return SVR_RET_END; + result = MysteryGiftServer_CallFunc(sServer); + if (result == SVR_RET_END) + { + *endVal = sServer->param; + MysteryGiftServer_Free(sServer); + FREE_AND_SET_NULL(sServer); + } + return result; +} + +static void MysteryGiftServer_Init(struct MysteryGiftServer * svr, const void *script, u32 sendPlayerId, u32 recvPlayerId) +{ + 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, sendPlayerId, recvPlayerId); +} + +static void MysteryGiftServer_Free(struct MysteryGiftServer * svr) +{ + Free(svr->card); + Free(svr->news); + Free(svr->recvBuffer); + Free(svr->linkGameData); +} + +static void MysteryGiftServer_InitSend(struct MysteryGiftServer * svr, u32 ident, const void *src, u32 size) +{ + ASSERT_SIZE_OK(257); + MysteryGiftLink_InitSend(&svr->manager, ident, src, size); +} + +// 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 (dynamicData != NULL) + return dynamicData; + else + return defaultData; +} + +static u32 MysteryGiftServer_Compare(const void *a, const void *b) +{ + if (b < a) + return 0; + else if (b == a) + return 1; + else + return 2; +} + +static u32 Server_Init(struct MysteryGiftServer * svr) +{ + svr->funcId = FUNC_RUN; + return SVR_RET_INIT; +} + +static u32 Server_Done(struct MysteryGiftServer * svr) +{ + return SVR_RET_END; +} + +static u32 Server_Recv(struct MysteryGiftServer * svr) +{ + if (MysteryGiftLink_Recv(&svr->manager)) + svr->funcId = FUNC_RUN; + return SVR_RET_ACTIVE; +} + +static u32 Server_Send(struct MysteryGiftServer * svr) +{ + if (MysteryGiftLink_Send(&svr->manager)) + svr->funcId = FUNC_RUN; + return SVR_RET_ACTIVE; +} + +static u32 Server_Run(struct MysteryGiftServer * svr) +{ + // process command + const struct MysteryGiftServerCmd * cmd = &svr->script[svr->cmdidx]; + const void *ptr; + svr->cmdidx++; + + switch (cmd->instr) + { + case SVR_RETURN: + ASSERT_PTR_EMPTY(354); + svr->funcId = FUNC_DONE; + svr->param = cmd->param; // Set for endVal in MysteryGiftServer_Run + break; + case SVR_SEND: + svr->funcId = FUNC_SEND; + break; + case SVR_RECV: + ASSERT_PTR_EMPTY(364); + MysteryGiftLink_InitRecv(&svr->manager, cmd->param, svr->recvBuffer); + svr->funcId = FUNC_RECV; + break; + case SVR_GOTO: + ASSERT_PARAM_EMPTY(370); + svr->cmdidx = 0; + svr->script = cmd->ptr; + break; + case SVR_COPY_GAME_DATA: + ASSERT_PARAM_EMPTY(376); + ASSERT_PTR_EMPTY(377); + memcpy(svr->linkGameData, svr->recvBuffer, sizeof(*svr->linkGameData)); + break; + case SVR_CHECK_GAME_DATA: + ASSERT_PARAM_EMPTY(382); + ASSERT_PTR_EMPTY(383); + svr->param = MysteryGift_ValidateLinkGameData(svr->linkGameData); + break; + case SVR_GOTO_IF_EQ: + if (svr->param == cmd->param) + { + svr->cmdidx = 0; + svr->script = cmd->ptr; + } + break; + case SVR_CHECK_EXISTING_CARD: + ASSERT_PARAM_EMPTY(396); + ptr = MysteryGiftServer_GetSendData(cmd->ptr, svr->card); + svr->param = MysteryGift_CompareCardFlags(ptr, svr->linkGameData, ptr); + break; + case SVR_READ_RESPONSE: + ASSERT_PARAM_EMPTY(402); + ASSERT_PTR_EMPTY(403); + svr->param = *(u32 *)svr->recvBuffer; + break; + case SVR_CHECK_EXISTING_STAMPS: + ASSERT_PARAM_EMPTY(408); + ptr = MysteryGiftServer_GetSendData(cmd->ptr, &svr->stamp); + svr->param = MysteryGift_CheckStamps(ptr, svr->linkGameData, ptr); + break; + case SVR_GET_CARD_STAT: + ASSERT_PTR_EMPTY(415); + svr->param = MysteryGift_GetCardStatFromLinkData(svr->linkGameData, cmd->param); + break; + case SVR_CHECK_QUESTIONNAIRE: + ASSERT_PARAM_EMPTY(420); + svr->param = MysteryGift_DoesQuestionnaireMatch(svr->linkGameData, cmd->ptr); + break; + case SVR_COMPARE: + ASSERT_PARAM_EMPTY(426); + svr->param = MysteryGiftServer_Compare(cmd->ptr, *(void **)svr->recvBuffer); + break; + case SVR_LOAD_NEWS: + ASSERT_PARAM_EMPTY(432); + MysteryGiftServer_InitSend(svr, MG_LINKID_NEWS, MysteryGiftServer_GetSendData(cmd->ptr, svr->news), sizeof(struct WonderNews)); + break; + case SVR_LOAD_CARD: + ASSERT_PARAM_EMPTY(438); + MysteryGiftServer_InitSend(svr, MG_LINKID_CARD, MysteryGiftServer_GetSendData(cmd->ptr, svr->card), sizeof(struct WonderCard)); + break; + case SVR_LOAD_STAMP: + ASSERT_PARAM_EMPTY(444); + MysteryGiftServer_InitSend(svr, MG_LINKID_STAMP, MysteryGiftServer_GetSendData(cmd->ptr, &svr->stamp), sizeof(svr->stamp)); + break; + case SVR_LOAD_RAM_SCRIPT: + if (cmd->ptr == NULL) + MysteryGiftServer_InitSend(svr, MG_LINKID_RAM_SCRIPT, svr->ramScript, svr->ramScriptSize); + else + MysteryGiftServer_InitSend(svr, MG_LINKID_RAM_SCRIPT, cmd->ptr, cmd->param); + break; + case SVR_LOAD_CLIENT_SCRIPT: + if (cmd->ptr == NULL) + MysteryGiftServer_InitSend(svr, MG_LINKID_CLIENT_SCRIPT, svr->clientScript, svr->clientScriptSize); + else + MysteryGiftServer_InitSend(svr, MG_LINKID_CLIENT_SCRIPT, cmd->ptr, cmd->param); + break; + case SVR_LOAD_EREADER_TRAINER: + ASSERT_PARAM_EMPTY(466); + MysteryGiftServer_InitSend(svr, MG_LINKID_EREADER_TRAINER, cmd->ptr, sizeof(struct BattleTowerEReaderTrainer)); + break; + case SVR_LOAD_MSG: + MysteryGiftServer_InitSend(svr, MG_LINKID_DYNAMIC_MSG, cmd->ptr, cmd->param); + break; + case SVR_LOAD_UNK_2: + MysteryGiftServer_InitSend(svr, MG_LINKID_UNK_2, cmd->ptr, cmd->param); + break; + case SVR_COPY_CARD: + ASSERT_PARAM_EMPTY(481); + memcpy(svr->card, cmd->ptr, sizeof(*svr->card)); + break; + case SVR_COPY_NEWS: + ASSERT_PARAM_EMPTY(486); + memcpy(svr->news, cmd->ptr, sizeof(*svr->news)); + break; + case SVR_COPY_STAMP: + ASSERT_PARAM_EMPTY(491); + svr->stamp = *(u32 *)cmd->ptr; + break; + case SVR_SET_RAM_SCRIPT: + svr->ramScript = cmd->ptr; + svr->ramScriptSize = cmd->param; + break; + case SVR_SET_CLIENT_SCRIPT: + svr->clientScript = cmd->ptr; + svr->clientScriptSize = cmd->param; + break; + case SVR_COPY_SAVED_CARD: + ASSERT_PTR_PARAM_EMPTY(506); + memcpy(svr->card, GetSavedWonderCard(), sizeof(*svr->card)); + DisableWonderCardSending(svr->card); + break; + case SVR_COPY_SAVED_NEWS: + ASSERT_PTR_PARAM_EMPTY(512); + memcpy(svr->news, GetSavedWonderNews(), sizeof(*svr->news)); + break; + case SVR_COPY_SAVED_RAM_SCRIPT: + ASSERT_PTR_PARAM_EMPTY(517); + svr->ramScript = GetSavedRamScriptIfValid(); + break; + case SVR_LOAD_UNK_1: + MysteryGiftServer_InitSend(svr, MG_LINKID_UNK_1, cmd->ptr, cmd->param); + break; + } + + return SVR_RET_ACTIVE; +} + +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 MysteryGiftServer_CallFunc(struct MysteryGiftServer * svr) +{ + u32 response; + ASSERT_VALID_FUNC(546) + response = sFuncTable[svr->funcId](svr); + ASSERT_VALID_FUNC(548) + return response; +} diff --git a/src/mystery_gift_show_card.c b/src/mystery_gift_show_card.c index c462bda76..16382ce8f 100644 --- a/src/mystery_gift_show_card.c +++ b/src/mystery_gift_show_card.c @@ -5,7 +5,7 @@ #include "new_menu_helpers.h" #include "pokemon_icon.h" #include "mystery_gift_menu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "battle_anim.h" #include "constants/mystery_gift.h" diff --git a/src/mystery_gift_show_news.c b/src/mystery_gift_show_news.c index b97e74c8c..e1112d726 100644 --- a/src/mystery_gift_show_news.c +++ b/src/mystery_gift_show_news.c @@ -2,7 +2,7 @@ #include "gflib.h" #include "menu_indicators.h" #include "new_menu_helpers.h" -#include "mevent.h" +#include "mystery_gift.h" #include "mystery_gift_menu.h" #include "menu.h" #include "link_rfu.h" diff --git a/src/new_game.c b/src/new_game.c index d6400d763..ab5fa9958 100644 --- a/src/new_game.c +++ b/src/new_game.c @@ -22,7 +22,7 @@ #include "berry.h" #include "easy_chat.h" #include "union_room_chat.h" -#include "mevent.h" +#include "mystery_gift.h" #include "renewable_hidden_items.h" #include "trainer_tower.h" #include "script.h" @@ -143,7 +143,7 @@ void NewGameInitData(void) ResetTrainerFanClub(); UnionRoomChat_InitializeRegisteredTexts(); ResetMiniGamesResults(); - InitMEventData(); + ClearMysteryGift(); SetAllRenewableItemFlags(); WarpToPlayersRoom(); RunScriptImmediately(EventScript_ResetAllMapFlags); diff --git a/src/script.c b/src/script.c index 641c63572..4d021606d 100644 --- a/src/script.c +++ b/src/script.c @@ -2,12 +2,12 @@ #include "script.h" #include "event_data.h" #include "quest_log.h" +#include "mystery_gift.h" #include "constants/maps.h" #include "constants/map_scripts.h" extern void ResetContextNpcTextColor(void); // field_specials extern u16 CalcCRC16WithTable(u8 *data, int length); // util -extern bool32 ValidateReceivedWonderCard(void); // mevent #define RAM_SCRIPT_MAGIC 51 @@ -554,7 +554,7 @@ bool32 ValidateRamScript(void) u8 *GetSavedRamScriptIfValid(void) { struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data; - if (!ValidateReceivedWonderCard()) + if (!ValidateSavedWonderCard()) return NULL; if (scriptData->magic != RAM_SCRIPT_MAGIC) return NULL; diff --git a/src/trade_scene.c b/src/trade_scene.c index 50f8e4780..8e0e2598d 100644 --- a/src/trade_scene.c +++ b/src/trade_scene.c @@ -6,7 +6,7 @@ #include "trade.h" #include "link.h" #include "link_rfu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "graphics.h" #include "strings.h" #include "menu.h" diff --git a/src/union_room.c b/src/union_room.c index 8b8410e3d..5c21a0ac6 100644 --- a/src/union_room.c +++ b/src/union_room.c @@ -20,7 +20,7 @@ #include "list_menu.h" #include "load_save.h" #include "menu.h" -#include "mevent.h" +#include "mystery_gift.h" #include "mystery_gift_menu.h" #include "new_menu_helpers.h" #include "overworld.h" diff --git a/src/union_room_message.c b/src/union_room_message.c index 21d74736f..a1368e9fa 100644 --- a/src/union_room_message.c +++ b/src/union_room_message.c @@ -1,6 +1,7 @@ #include "global.h" #include "link_rfu.h" -#include "mevent_server.h" +#include "mystery_gift_server.h" +#include "mystery_gift_client.h" #include "constants/union_room.h" ALIGNED(4) const u8 gText_UR_EmptyString[] = _(""); @@ -558,18 +559,18 @@ const u8 *const gTexts_UR_GladToMeetYou[GENDER_COUNT] = { ALIGNED(4) const u8 gText_UR_FinishedCheckingPlayersTrainerCard[] = _("Finished checking {SPECIAL_F7 0x01}'s\nTRAINER CARD.{PAUSE 60}"); ALIGNED(4) static const u8 sText_CanceledReadingCard[] = _("Canceled reading the Card."); -static const struct mevent_client_cmd sClientScript_DynamicError[] = { - CLI_RECEIVE(0x15), - CLI_RECVBUF, - CLI_SENDALL, - CLI_RETURN(0x0e) +static const struct MysteryGiftClientCmd sClientScript_DynamicError[] = { + {CLI_RECV, MG_LINKID_DYNAMIC_MSG}, + {CLI_COPY_MSG}, + {CLI_SEND_READY_END}, + {CLI_RETURN, CLI_MSG_BUFFER_FAILURE} }; -const struct mevent_server_cmd gServerScript_ClientCanceledCard[] = { - SRV_SEND(0x20, sClientScript_DynamicError), - SRV_WAITSND, - SRV_SENDSTR(0x1b, sText_CanceledReadingCard), - SRV_WAITSND, - SRV_RECV(0x14), - SRV_RETURN(0x09) +const struct MysteryGiftServerCmd gServerScript_ClientCanceledCard[] = { + {SVR_LOAD_CLIENT_SCRIPT, PTR_ARG(sClientScript_DynamicError)}, + {SVR_SEND}, + {SVR_LOAD_MSG, PTR_ARG(sText_CanceledReadingCard)}, + {SVR_SEND}, + {SVR_RECV, MG_LINKID_READY_END}, + {SVR_RETURN, SVR_MSG_CLIENT_CANCELED} }; diff --git a/src/wonder_news.c b/src/wonder_news.c new file mode 100644 index 000000000..03dd4c73f --- /dev/null +++ b/src/wonder_news.c @@ -0,0 +1,154 @@ +#include "global.h" +#include "mystery_gift.h" +#include "random.h" +#include "event_data.h" +#include "wonder_news.h" +#include "constants/items.h" + +// Every 4th reward for sending Wonder News to a link partner is a "big" reward. +#define MAX_SENT_REWARD 4 + +// Only up to 5 rewards can be received in a short period. After this the player +// must take 500 steps before any more rewards can be received. +#define MAX_REWARD 5 + +static u32 GetRewardItem(struct WonderNewsMetadata *); +static u32 GetRewardType(struct WonderNewsMetadata *); +static void IncrementRewardCounter(struct WonderNewsMetadata *); +static void IncrementSentRewardCounter(struct WonderNewsMetadata *); +static void ResetSentRewardCounter(struct WonderNewsMetadata *); + +void WonderNews_SetReward(u32 newsType) +{ + struct WonderNewsMetadata *data = GetSavedWonderNewsMetadata(); + + data->newsType = newsType; + switch (newsType) + { + case WONDER_NEWS_NONE: + break; + case WONDER_NEWS_RECV_FRIEND: + case WONDER_NEWS_RECV_WIRELESS: + // Random berry between ITEM_RAZZ_BERRY and ITEM_NOMEL_BERRY + data->berry = (Random() % 15) + ITEM_TO_BERRY(ITEM_RAZZ_BERRY); + break; + case WONDER_NEWS_SENT: + // Random berry between ITEM_CHERI_BERRY and ITEM_IAPAPA_BERRY + data->berry = (Random() % 15) + ITEM_TO_BERRY(ITEM_CHERI_BERRY); + break; + } +} + +void WonderNews_Reset(void) +{ + struct WonderNewsMetadata *data = GetSavedWonderNewsMetadata(); + + data->newsType = WONDER_NEWS_NONE; + data->sentRewardCounter = 0; + data->rewardCounter = 0; + data->berry = 0; + VarSet(VAR_WONDER_NEWS_STEP_COUNTER, 0); +} + +void WonderNews_IncrementStepCounter(void) +{ + u16 *stepCounter = GetVarPointer(VAR_WONDER_NEWS_STEP_COUNTER); + struct WonderNewsMetadata *data = GetSavedWonderNewsMetadata(); + + // If the player has reached the reward limit, start counting steps. + // When they reach 500 steps reset the reward counter to allow them to + // receive rewards again. + if (data->rewardCounter >= MAX_REWARD && ++(*stepCounter) >= 500) + { + data->rewardCounter = 0; + *stepCounter = 0; + } +} + +u16 WonderNews_GetRewardInfo(void) +{ + u16 *result = &gSpecialVar_Result; + struct WonderNewsMetadata *data = GetSavedWonderNewsMetadata(); + u16 rewardType; + + if (!IsMysteryGiftEnabled() || !ValidateSavedWonderNews()) + return NEWS_REWARD_NONE; + + rewardType = GetRewardType(data); + + switch (rewardType) + { + case NEWS_REWARD_RECV_SMALL: + case NEWS_REWARD_RECV_BIG: + *result = GetRewardItem(data); + break; + case NEWS_REWARD_SENT_SMALL: + *result = GetRewardItem(data); + IncrementSentRewardCounter(data); + break; + case NEWS_REWARD_SENT_BIG: + *result = GetRewardItem(data); + ResetSentRewardCounter(data); + break; + case NEWS_REWARD_NONE: + case NEWS_REWARD_WAITING: + case NEWS_REWARD_AT_MAX: + break; + } + + return rewardType; +} + +static u32 GetRewardItem(struct WonderNewsMetadata *data) +{ + u32 itemId; + + data->newsType = WONDER_NEWS_NONE; + itemId = data->berry + FIRST_BERRY_INDEX - 1; + data->berry = 0; + IncrementRewardCounter(data); + return itemId; +} + +static void ResetSentRewardCounter(struct WonderNewsMetadata *data) +{ + data->sentRewardCounter = 0; +} + +// Track number of times a reward was received (or attmepted to receive) for sending Wonder News to a link partner. +static void IncrementSentRewardCounter(struct WonderNewsMetadata *data) +{ + data->sentRewardCounter++; + if (data->sentRewardCounter > MAX_SENT_REWARD) + data->sentRewardCounter = MAX_SENT_REWARD; +} + +static void IncrementRewardCounter(struct WonderNewsMetadata *data) +{ + data->rewardCounter++; + if (data->rewardCounter > MAX_REWARD) + data->rewardCounter = MAX_REWARD; +} + +static u32 GetRewardType(struct WonderNewsMetadata *data) +{ + if (data->rewardCounter == MAX_REWARD) + return NEWS_REWARD_AT_MAX; + + switch (data->newsType) + { + case WONDER_NEWS_NONE: + return NEWS_REWARD_WAITING; + case WONDER_NEWS_RECV_FRIEND: + return NEWS_REWARD_RECV_SMALL; + case WONDER_NEWS_RECV_WIRELESS: + return NEWS_REWARD_RECV_BIG; + case WONDER_NEWS_SENT: + if (data->sentRewardCounter < MAX_SENT_REWARD - 1) + return NEWS_REWARD_SENT_SMALL; + return NEWS_REWARD_SENT_BIG; + default: + AGB_ASSERT_EX(0, ABSPATH("menews_jisan.c"), 383); + return NEWS_REWARD_NONE; + } +} diff --git a/sym_common.txt b/sym_common.txt index e130c3bf4..1e57985da 100644 --- a/sym_common.txt +++ b/sym_common.txt @@ -40,7 +40,7 @@ .include "fame_checker.o" .include "help_system_util.o" .align 4 - .include "mevent.o" + .include "ereader_screen.o" .align 4 .include "battle_controller_pokedude.o" .align 4 diff --git a/sym_ewram.txt b/sym_ewram.txt index f957d320b..cee4e8281 100644 --- a/sym_ewram.txt +++ b/sym_ewram.txt @@ -121,10 +121,10 @@ .include "src/slot_machine.o" .include "src/roamer.o" .include "src/mystery_gift_menu.o" - .include "src/mevent.o" - .include "src/mevent_server_helpers.o" - .include "src/mevent_client.o" - .include "src/mevent_server.o" + .include "src/mystery_gift.o" + .include "src/mystery_gift_link.o" + .include "src/mystery_gift_client.o" + .include "src/mystery_gift_server.o" .include "src/mystery_gift_show_card.o" .include "src/mystery_gift_show_news.o" .include "src/seagallop.o"