tumbledemerald-legacy/src/mystery_gift_menu.c

1619 lines
46 KiB
C
Raw Normal View History

2022-05-19 19:14:13 +02:00
#include "global.h"
#include "main.h"
#include "text.h"
#include "task.h"
#include "malloc.h"
#include "gpu_regs.h"
#include "scanline_effect.h"
#include "text_window.h"
#include "bg.h"
#include "window.h"
#include "strings.h"
#include "text_window.h"
#include "menu.h"
#include "palette.h"
#include "constants/songs.h"
#include "sound.h"
#include "mystery_gift_menu.h"
#include "union_room.h"
#include "title_screen.h"
#include "ereader_screen.h"
#include "international_string_util.h"
#include "list_menu.h"
#include "string_util.h"
#include "mystery_gift.h"
#include "mystery_gift_view.h"
#include "save.h"
#include "link.h"
#include "mystery_gift_client.h"
#include "mystery_gift_server.h"
#include "event_data.h"
#include "link_rfu.h"
#include "wonder_news.h"
#include "constants/cable_club.h"
#define LIST_MENU_TILE_NUM 10
#define LIST_MENU_PAL_NUM 224
static void LoadMysteryGiftTextboxBorder(u8 bgId);
static void CreateMysteryGiftTask(void);
static void Task_MysteryGift(u8 taskId);
EWRAM_DATA static u8 sDownArrowCounterAndYCoordIdx[8] = {};
EWRAM_DATA bool8 gGiftIsFromEReader = FALSE;
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 var; // Multipurpose
u16 unused1;
u16 unused2;
u16 unused3;
u8 state;
u8 textState;
u8 unused4;
u8 unused5;
bool8 isWonderNews;
bool8 sourceIsFriend;
u8 msgId;
u8 * clientMsg;
};
static const struct BgTemplate sBGTemplates[] = {
{
.bg = 0,
.charBaseIndex = 2,
.mapBaseIndex = 15,
.screenSize = 0,
.paletteMode = 0,
.priority = 0,
.baseTile = 0x000
}, {
.bg = 1,
.charBaseIndex = 0,
.mapBaseIndex = 14,
.screenSize = 0,
.paletteMode = 0,
.priority = 1,
.baseTile = 0x000
}, {
.bg = 2,
.charBaseIndex = 0,
.mapBaseIndex = 13,
.screenSize = 0,
.paletteMode = 0,
.priority = 2,
.baseTile = 0x000
}, {
.bg = 3,
.charBaseIndex = 0,
.mapBaseIndex = 12,
.screenSize = 0,
.paletteMode = 0,
.priority = 3,
.baseTile = 0x000
}
};
static const struct WindowTemplate sMainWindows[] = {
{
.bg = 0,
.tilemapLeft = 0,
.tilemapTop = 0,
.width = 30,
.height = 2,
.paletteNum = 12,
.baseBlock = 0x0013
}, {
.bg = 0,
.tilemapLeft = 1,
.tilemapTop = 15,
.width = 28,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x004f
}, {
.bg = 0,
.tilemapLeft = 0,
.tilemapTop = 15,
.width = 30,
.height = 5,
.paletteNum = 13,
.baseBlock = 0x004f
},
DUMMY_WIN_TEMPLATE
};
static const struct WindowTemplate sWindowTemplate_YesNoMsg_Wide = {
.bg = 0,
.tilemapLeft = 1,
.tilemapTop = 15,
.width = 28,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x00e5
};
static const struct WindowTemplate sWindowTemplate_YesNoMsg = {
.bg = 0,
.tilemapLeft = 1,
.tilemapTop = 15,
.width = 20,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x00e5
};
static const struct WindowTemplate sWindowTemplate_GiftSelect = {
.bg = 0,
.tilemapLeft = 1,
.tilemapTop = 15,
.width = 19,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x00e5
};
static const struct WindowTemplate sWindowTemplate_ThreeOptions = {
.bg = 0,
.tilemapLeft = 8,
.tilemapTop = 6,
.width = 14,
.height = 6,
.paletteNum = 12,
.baseBlock = 0x0155
};
static const struct WindowTemplate sWindowTemplate_YesNoBox = {
.bg = 0,
.tilemapLeft = 23,
.tilemapTop = 15,
.width = 6,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x0155
};
static const struct WindowTemplate sWindowTemplate_GiftSelect_3Options = {
.bg = 0,
.tilemapLeft = 22,
.tilemapTop = 11,
.width = 7,
.height = 8,
.paletteNum = 12,
.baseBlock = 0x0155
};
static const struct WindowTemplate sWindowTemplate_GiftSelect_2Options = {
.bg = 0,
.tilemapLeft = 22,
.tilemapTop = 13,
.width = 7,
.height = 6,
.paletteNum = 12,
.baseBlock = 0x0155
};
static const struct WindowTemplate sWindowTemplate_GiftSelect_1Option = {
.bg = 0,
.tilemapLeft = 22,
.tilemapTop = 15,
.width = 7,
.height = 4,
.paletteNum = 12,
.baseBlock = 0x0155
};
static const struct ListMenuItem sListMenuItems_CardsOrNews[] = {
{ gText_WonderCards, 0 },
{ gText_WonderNews, 1 },
{ gText_Exit3, LIST_CANCEL }
};
static const struct ListMenuItem sListMenuItems_WirelessOrFriend[] = {
{ gText_WirelessCommunication, 0 },
{ gText_Friend2, 1 },
{ gText_Cancel2, LIST_CANCEL }
};
static const struct ListMenuTemplate sListMenuTemplate_ThreeOptions = {
.items = NULL,
.moveCursorFunc = ListMenuDefaultCursorMoveFunc,
.itemPrintFunc = NULL,
.totalItems = 3,
.maxShowed = 3,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 1,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = 0,
.fontId = FONT_NORMAL,
.cursorKind = 0
};
static const struct ListMenuItem sListMenuItems_ReceiveSendToss[] = {
{ gText_Receive, 0 },
{ gText_Send, 1 },
{ gText_Toss, 2 },
{ gText_Cancel2, LIST_CANCEL }
};
static const struct ListMenuItem sListMenuItems_ReceiveToss[] = {
{ gText_Receive, 0 },
{ gText_Toss, 2 },
{ gText_Cancel2, LIST_CANCEL }
};
static const struct ListMenuItem sListMenuItems_ReceiveSend[] = {
{ gText_Receive, 0 },
{ gText_Send, 1 },
{ gText_Cancel2, LIST_CANCEL }
};
static const struct ListMenuItem sListMenuItems_Receive[] = {
{ gText_Receive, 0 },
{ gText_Cancel2, LIST_CANCEL }
};
static const struct ListMenuTemplate sListMenu_ReceiveSendToss = {
.items = sListMenuItems_ReceiveSendToss,
.moveCursorFunc = ListMenuDefaultCursorMoveFunc,
.itemPrintFunc = NULL,
.totalItems = 4,
.maxShowed = 4,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 1,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = 0,
.fontId = FONT_NORMAL,
.cursorKind = 0
};
static const struct ListMenuTemplate sListMenu_ReceiveToss = {
.items = sListMenuItems_ReceiveToss,
.moveCursorFunc = ListMenuDefaultCursorMoveFunc,
.itemPrintFunc = NULL,
.totalItems = 3,
.maxShowed = 3,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 1,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = 0,
.fontId = FONT_NORMAL,
.cursorKind = 0
};
static const struct ListMenuTemplate sListMenu_ReceiveSend = {
.items = sListMenuItems_ReceiveSend,
.moveCursorFunc = ListMenuDefaultCursorMoveFunc,
.itemPrintFunc = NULL,
.totalItems = 3,
.maxShowed = 3,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 1,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = 0,
.fontId = FONT_NORMAL,
.cursorKind = 0
};
static const struct ListMenuTemplate sListMenu_Receive = {
.items = sListMenuItems_Receive,
.moveCursorFunc = ListMenuDefaultCursorMoveFunc,
.itemPrintFunc = NULL,
.totalItems = 2,
.maxShowed = 2,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 1,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = 0,
.fontId = FONT_NORMAL,
.cursorKind = 0
};
static const u8 *const sUnusedMenuTexts[] = {
gText_VarietyOfEventsImportedWireless,
gText_WonderCardsInPossession,
gText_ReadNewsThatArrived,
gText_ReturnToTitle
};
ALIGNED(2) static const u8 sTextColors_TopMenu[] = { TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GRAY };
ALIGNED(2) static const u8 sTextColors_TopMenu_Copy[] = { TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GRAY };
ALIGNED(2) static const u8 sMG_Ereader_TextColor_2[] = { TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_LIGHT_GRAY };
static void VBlankCB_MysteryGiftEReader(void)
{
ProcessSpriteCopyRequests();
LoadOam();
TransferPlttBuffer();
}
void CB2_MysteryGiftEReader(void)
{
RunTasks();
RunTextPrinters();
AnimateSprites();
BuildOamBuffer();
}
static bool32 HandleMysteryGiftOrEReaderSetup(s32 isEReader)
{
switch (gMain.state)
{
case 0:
SetVBlankCallback(NULL);
ResetPaletteFade();
ResetSpriteData();
FreeAllSpritePalettes();
ResetTasks();
ScanlineEffect_Stop();
ResetBgsAndClearDma3BusyFlags(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(BG_SCREEN_SIZE));
SetBgTilemapBuffer(2, Alloc(BG_SCREEN_SIZE));
SetBgTilemapBuffer(1, Alloc(BG_SCREEN_SIZE));
SetBgTilemapBuffer(0, Alloc(BG_SCREEN_SIZE));
LoadMysteryGiftTextboxBorder(3);
InitWindows(sMainWindows);
DeactivateAllTextPrinters();
ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
SetGpuReg(REG_OFFSET_BLDY, 0);
gMain.state++;
break;
case 1:
LoadPalette(sTextboxBorder_Pal, 0, 0x20);
LoadPalette(GetTextWindowPalette(2), 0xd0, 0x20);
Menu_LoadStdPalAt(0xC0);
LoadUserWindowBorderGfx(0, 0xA, 0xE0);
LoadUserWindowBorderGfx_(0, 0x1, 0xF0);
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(3);
PrintMysteryGiftOrEReaderTopMenu(isEReader, FALSE);
gMain.state++;
break;
case 2:
CopyBgTilemapBufferToVram(3);
CopyBgTilemapBufferToVram(2);
CopyBgTilemapBufferToVram(1);
CopyBgTilemapBufferToVram(0);
gMain.state++;
break;
case 3:
ShowBg(0);
ShowBg(3);
PlayBGM(MUS_RG_MYSTERY_GIFT);
SetVBlankCallback(VBlankCB_MysteryGiftEReader);
EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
return TRUE;
}
return FALSE;
}
void CB2_InitMysteryGift(void)
{
if (HandleMysteryGiftOrEReaderSetup(FALSE))
{
SetMainCallback2(CB2_MysteryGiftEReader);
gGiftIsFromEReader = FALSE;
CreateMysteryGiftTask();
}
RunTasks();
}
void CB2_InitEReader(void)
{
if (HandleMysteryGiftOrEReaderSetup(TRUE))
{
SetMainCallback2(CB2_MysteryGiftEReader);
gGiftIsFromEReader = TRUE;
CreateEReaderTask();
}
}
void MainCB_FreeAllBuffersAndReturnToInitTitleScreen(void)
{
gGiftIsFromEReader = FALSE;
FreeAllWindowBuffers();
Free(GetBgTilemapBuffer(0));
Free(GetBgTilemapBuffer(1));
Free(GetBgTilemapBuffer(2));
Free(GetBgTilemapBuffer(3));
SetMainCallback2(CB2_InitTitleScreen);
}
void PrintMysteryGiftOrEReaderTopMenu(bool8 isEReader, bool32 useCancel)
{
const u8 * header;
const u8 * options;
FillWindowPixelBuffer(0, 0);
if (!isEReader)
{
header = gText_MysteryGift;
options = !useCancel ? gText_PickOKExit : gText_PickOKCancel;
}
else
{
header = gJPText_MysteryGift;
options = gJPText_DecideStop;
}
AddTextPrinterParameterized4(0, FONT_NORMAL, 4, 1, 0, 0, sTextColors_TopMenu, TEXT_SKIP_DRAW, header);
AddTextPrinterParameterized4(0, FONT_SMALL, GetStringRightAlignXOffset(FONT_SMALL, options, 0xDE), 1, 0, 0, sTextColors_TopMenu, TEXT_SKIP_DRAW, options);
CopyWindowToVram(0, COPYWIN_GFX);
PutWindowTilemap(0);
}
void MG_DrawTextBorder(u8 windowId)
{
DrawTextBorderOuter(windowId, 0x01, 0xF);
}
void MG_DrawCheckerboardPattern(u32 bg)
{
s32 i = 0, j;
FillBgTilemapBufferRect(bg, 0x003, 0, 0, 32, 2, 0x11);
for (i = 0; i < 18; i++)
{
for (j = 0; j < 32; j++)
{
if ((i & 1) != (j & 1))
FillBgTilemapBufferRect(bg, 1, j, i + 2, 1, 1, 0x11);
else
FillBgTilemapBufferRect(bg, 2, j, i + 2, 1, 1, 0x11);
}
}
}
static void ClearScreenInBg0(bool32 ignoreTopTwoRows)
{
switch (ignoreTopTwoRows)
{
case 0:
FillBgTilemapBufferRect(0, 0, 0, 0, 32, 32, 0x11);
break;
case 1:
FillBgTilemapBufferRect(0, 0, 0, 2, 32, 30, 0x11);
break;
}
CopyBgTilemapBufferToVram(0);
}
void AddTextPrinterToWindow1(const u8 *str)
{
StringExpandPlaceholders(gStringVar4, str);
FillWindowPixelBuffer(1, 0x11);
AddTextPrinterParameterized4(1, FONT_NORMAL, 0, 1, 0, 0, sMG_Ereader_TextColor_2, 0, gStringVar4);
DrawTextBorderOuter(1, 0x001, 0xF);
PutWindowTilemap(1);
CopyWindowToVram(1, COPYWIN_FULL);
}
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)
{
case 0:
AddTextPrinterToWindow1(str);
(*textState)++;
break;
case 1:
DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]);
if (({JOY_NEW(A_BUTTON | B_BUTTON);}))
(*textState)++;
break;
case 2:
DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]);
*textState = 0;
ClearTextWindow();
return TRUE;
case 0xFF:
*textState = 2;
return FALSE;
}
return FALSE;
}
static void HideDownArrow(void)
{
DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, FALSE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]);
}
static void ShowDownArrow(void)
{
DrawDownArrow(1, DOWN_ARROW_X, DOWN_ARROW_Y, 1, TRUE, &sDownArrowCounterAndYCoordIdx[0], &sDownArrowCounterAndYCoordIdx[1]);
}
// Unused
static bool32 HideDownArrowAndWaitButton(u8 * textState)
{
switch (*textState)
{
case 0:
HideDownArrow();
if (JOY_NEW(A_BUTTON | B_BUTTON))
(*textState)++;
break;
case 1:
ShowDownArrow();
*textState = 0;
return TRUE;
}
return FALSE;
}
static bool32 PrintStringAndWait2Seconds(u8 * counter, const u8 * str)
{
if (*counter == 0)
AddTextPrinterToWindow1(str);
if (++(*counter) > 120)
{
*counter = 0;
ClearTextWindow();
return TRUE;
}
else
{
return FALSE;
}
}
static u32 MysteryGift_HandleThreeOptionMenu(u8 * unused0, u16 * unused1, u8 whichMenu)
{
struct ListMenuTemplate listMenuTemplate = sListMenuTemplate_ThreeOptions;
struct WindowTemplate windowTemplate = sWindowTemplate_ThreeOptions;
s32 width;
s32 response;
if (whichMenu == 0)
listMenuTemplate.items = sListMenuItems_CardsOrNews;
else
listMenuTemplate.items = sListMenuItems_WirelessOrFriend;
width = Intl_GetListMenuWidth(&listMenuTemplate);
if (width & 1)
width++;
windowTemplate.width = width;
if (width < 30)
windowTemplate.tilemapLeft = (30 - width) / 2;
else
windowTemplate.tilemapLeft = 0;
response = DoMysteryGiftListMenu(&windowTemplate, &listMenuTemplate, 1, LIST_MENU_TILE_NUM, LIST_MENU_PAL_NUM);
if (response != LIST_NOTHING_CHOSEN)
{
ClearWindowTilemap(2);
CopyWindowToVram(2, COPYWIN_MAP);
}
return response;
}
s8 DoMysteryGiftYesNo(u8 * textState, u16 * windowId, bool8 yesNoBoxPlacement, const u8 * str)
{
struct WindowTemplate windowTemplate;
s8 input;
switch (*textState)
{
case 0:
// Print question message
StringExpandPlaceholders(gStringVar4, str);
if (yesNoBoxPlacement == 0)
*windowId = AddWindow(&sWindowTemplate_YesNoMsg_Wide);
else
*windowId = AddWindow(&sWindowTemplate_YesNoMsg);
FillWindowPixelBuffer(*windowId, 0x11);
AddTextPrinterParameterized4(*windowId, FONT_NORMAL, 0, 1, 0, 0, sMG_Ereader_TextColor_2, 0, gStringVar4);
DrawTextBorderOuter(*windowId, 0x001, 0x0F);
CopyWindowToVram(*windowId, COPYWIN_GFX);
PutWindowTilemap(*windowId);
(*textState)++;
break;
case 1:
// Create Yes/No
windowTemplate = sWindowTemplate_YesNoBox;
if (yesNoBoxPlacement == 0)
windowTemplate.tilemapTop = 9;
else
windowTemplate.tilemapTop = 15;
CreateYesNoMenu(&windowTemplate, 10, 14, 0);
(*textState)++;
break;
case 2:
// Handle Yes/No input
input = Menu_ProcessInputNoWrapClearOnChoose();
if (input == MENU_B_PRESSED || input == 0 || input == 1)
{
*textState = 0;
rbox_fill_rectangle(*windowId);
ClearWindowTilemap(*windowId);
CopyWindowToVram(*windowId, COPYWIN_MAP);
RemoveWindow(*windowId);
return input;
}
break;
case 0xFF:
*textState = 0;
rbox_fill_rectangle(*windowId);
ClearWindowTilemap(*windowId);
CopyWindowToVram(*windowId, COPYWIN_MAP);
RemoveWindow(*windowId);
return MENU_B_PRESSED;
}
return MENU_NOTHING_CHOSEN;
}
// Handle the "Receive/Send/Toss" menu that appears when selecting Wonder Card/News
static s32 HandleGiftSelectMenu(u8 * textState, u16 * windowId, bool32 cannotToss, bool32 cannotSend)
{
struct WindowTemplate windowTemplate;
s32 input;
switch (*textState)
{
case 0:
// Print menu message
if (!cannotToss)
StringExpandPlaceholders(gStringVar4, gText_WhatToDoWithCards);
else
StringExpandPlaceholders(gStringVar4, gText_WhatToDoWithNews);
*windowId = AddWindow(&sWindowTemplate_GiftSelect);
FillWindowPixelBuffer(*windowId, 0x11);
AddTextPrinterParameterized4(*windowId, FONT_NORMAL, 0, 1, 0, 0, sMG_Ereader_TextColor_2, 0, gStringVar4);
DrawTextBorderOuter(*windowId, 0x001, 0x0F);
CopyWindowToVram(*windowId, COPYWIN_GFX);
PutWindowTilemap(*windowId);
(*textState)++;
break;
case 1:
windowTemplate = sWindowTemplate_YesNoBox;
if (cannotSend)
{
if (!cannotToss)
input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_2Options, &sListMenu_ReceiveToss, 1, LIST_MENU_TILE_NUM, LIST_MENU_PAL_NUM);
else
input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_1Option, &sListMenu_Receive, 1, LIST_MENU_TILE_NUM, LIST_MENU_PAL_NUM);
}
else
{
if (!cannotToss)
input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_3Options, &sListMenu_ReceiveSendToss, 1, LIST_MENU_TILE_NUM, LIST_MENU_PAL_NUM);
else
input = DoMysteryGiftListMenu(&sWindowTemplate_GiftSelect_2Options, &sListMenu_ReceiveSend, 1, LIST_MENU_TILE_NUM, LIST_MENU_PAL_NUM);
}
if (input != LIST_NOTHING_CHOSEN)
{
*textState = 0;
rbox_fill_rectangle(*windowId);
ClearWindowTilemap(*windowId);
CopyWindowToVram(*windowId, COPYWIN_MAP);
RemoveWindow(*windowId);
return input;
}
break;
case 0xFF:
*textState = 0;
rbox_fill_rectangle(*windowId);
ClearWindowTilemap(*windowId);
CopyWindowToVram(*windowId, COPYWIN_MAP);
RemoveWindow(*windowId);
return LIST_CANCEL;
}
return LIST_NOTHING_CHOSEN;
}
static bool32 ValidateCardOrNews(bool32 isWonderNews)
{
if (!isWonderNews)
return ValidateSavedWonderCard();
else
return ValidateSavedWonderNews();
}
static bool32 HandleLoadWonderCardOrNews(u8 * state, bool32 isWonderNews)
{
switch (*state)
{
case 0:
if (!isWonderNews)
WonderCard_Init(GetSavedWonderCard(), GetSavedWonderCardMetadata());
else
WonderNews_Init(GetSavedWonderNews());
(*state)++;
break;
case 1:
if (!isWonderNews)
{
if (!WonderCard_Enter())
return FALSE;
}
else
{
if (!WonderNews_Enter())
return FALSE;
}
*state = 0;
return TRUE;
}
return FALSE;
}
static bool32 ClearSavedNewsOrCard(bool32 isWonderNews)
{
if (!isWonderNews)
ClearSavedWonderCardAndRelated();
else
ClearSavedWonderNewsAndRelated();
return TRUE;
}
static bool32 ExitWonderCardOrNews(bool32 isWonderNews, bool32 useCancel)
{
if (!isWonderNews)
{
if (WonderCard_Exit(useCancel))
{
WonderCard_Destroy();
return TRUE;
}
else
{
return FALSE;
}
}
else
{
if (WonderNews_Exit(useCancel))
{
WonderNews_Destroy();
return TRUE;
}
else
{
return FALSE;
}
}
}
static s32 AskDiscardGift(u8 * textState, u16 * windowId, bool32 isWonderNews)
{
if (!isWonderNews)
return DoMysteryGiftYesNo(textState, windowId, TRUE, gText_IfThrowAwayCardEventWontHappen);
else
return DoMysteryGiftYesNo(textState, windowId, TRUE, gText_OkayToDiscardNews);
}
static bool32 PrintThrownAway(u8 * textState, bool32 isWonderNews)
{
if (!isWonderNews)
return PrintMysteryGiftMenuMessage(textState, gText_WonderCardThrownAway);
else
return PrintMysteryGiftMenuMessage(textState, gText_WonderNewsThrownAway);
}
static bool32 SaveOnMysteryGiftMenu(u8 * state)
{
switch (*state)
{
case 0:
AddTextPrinterToWindow1(gText_DataWillBeSaved);
(*state)++;
break;
case 1:
TrySavingData(SAVE_NORMAL);
(*state)++;
break;
case 2:
AddTextPrinterToWindow1(gText_SaveCompletedPressA);
(*state)++;
break;
case 3:
if (JOY_NEW(A_BUTTON | B_BUTTON))
(*state)++;
break;
case 4:
*state = 0;
ClearTextWindow();
return TRUE;
}
return FALSE;
}
static const u8 * GetClientResultMessage(bool32 * successMsg, bool8 isWonderNews, bool8 sourceIsFriend, u32 msgId)
{
const u8 * msg = NULL;
*successMsg = FALSE;
switch (msgId)
{
case CLI_MSG_NOTHING_SENT:
*successMsg = FALSE;
msg = gText_NothingSentOver;
break;
case CLI_MSG_RECORD_UPLOADED:
*successMsg = FALSE;
msg = gText_RecordUploadedViaWireless;
break;
case CLI_MSG_CARD_RECEIVED:
*successMsg = TRUE;
msg = !sourceIsFriend ? gText_WonderCardReceived : gText_WonderCardReceivedFrom;
break;
case CLI_MSG_NEWS_RECEIVED:
*successMsg = TRUE;
msg = !sourceIsFriend ? gText_WonderNewsReceived : gText_WonderNewsReceivedFrom;
break;
case CLI_MSG_STAMP_RECEIVED:
*successMsg = TRUE;
msg = gText_NewStampReceived;
break;
case CLI_MSG_HAD_CARD:
*successMsg = FALSE;
msg = gText_AlreadyHadCard;
break;
case CLI_MSG_HAD_STAMP:
*successMsg = FALSE;
msg = gText_AlreadyHadStamp;
break;
case CLI_MSG_HAD_NEWS:
*successMsg = FALSE;
msg = gText_AlreadyHadNews;
break;
case CLI_MSG_NO_ROOM_STAMPS:
*successMsg = FALSE;
msg = gText_NoMoreRoomForStamps;
break;
case CLI_MSG_COMM_CANCELED:
*successMsg = FALSE;
msg = gText_CommunicationCanceled;
break;
case CLI_MSG_CANT_ACCEPT:
*successMsg = FALSE;
msg = !isWonderNews ? gText_CantAcceptCardFromTrainer : gText_CantAcceptNewsFromTrainer;
break;
case CLI_MSG_COMM_ERROR:
*successMsg = FALSE;
msg = gText_CommunicationError;
break;
case CLI_MSG_TRAINER_RECEIVED:
*successMsg = TRUE;
msg = gText_NewTrainerReceived;
break;
case CLI_MSG_BUFFER_SUCCESS:
*successMsg = TRUE;
// msg is NULL, use buffer
break;
case CLI_MSG_BUFFER_FAILURE:
*successMsg = FALSE;
// msg is NULL, use buffer
break;
}
return msg;
}
static bool32 PrintSuccessMessage(u8 * state, const u8 * msg, u16 * timer)
{
switch (*state)
{
case 0:
if (msg != NULL)
AddTextPrinterToWindow1(msg);
PlayFanfare(MUS_OBTAIN_ITEM);
*timer = 0;
(*state)++;
break;
case 1:
if (++(*timer) > 240)
(*state)++;
break;
case 2:
if (IsFanfareTaskInactive())
{
*state = 0;
ClearTextWindow();
return TRUE;
}
break;
}
return FALSE;
}
static const u8 * GetServerResultMessage(bool32 * wonderSuccess, bool8 sourceIsFriend, u32 msgId)
{
const u8 * result = gText_CommunicationError;
*wonderSuccess = FALSE;
switch (msgId)
{
case SVR_MSG_NOTHING_SENT:
result = gText_NothingSentOver;
break;
case SVR_MSG_RECORD_UPLOADED:
result = gText_RecordUploadedViaWireless;
break;
case SVR_MSG_CARD_SENT:
result = gText_WonderCardSentTo;
*wonderSuccess = TRUE;
break;
case SVR_MSG_NEWS_SENT:
result = gText_WonderNewsSentTo;
*wonderSuccess = TRUE;
break;
case SVR_MSG_STAMP_SENT:
result = gText_StampSentTo;
break;
case SVR_MSG_HAS_CARD:
result = gText_OtherTrainerHasCard;
break;
case SVR_MSG_HAS_STAMP:
result = gText_OtherTrainerHasStamp;
break;
case SVR_MSG_HAS_NEWS:
result = gText_OtherTrainerHasNews;
break;
case SVR_MSG_NO_ROOM_STAMPS:
result = gText_NoMoreRoomForStamps;
break;
case SVR_MSG_CLIENT_CANCELED:
result = gText_OtherTrainerCanceled;
break;
case SVR_MSG_CANT_SEND_GIFT_1:
result = gText_CantSendGiftToTrainer;
break;
case SVR_MSG_COMM_ERROR:
result = gText_CommunicationError;
break;
case SVR_MSG_GIFT_SENT_1:
result = gText_GiftSentTo;
break;
case SVR_MSG_GIFT_SENT_2:
result = gText_GiftSentTo;
break;
case SVR_MSG_CANT_SEND_GIFT_2:
result = gText_CantSendGiftToTrainer;
break;
}
return result;
}
static bool32 PrintServerResultMessage(u8 * state, u16 * timer, bool8 sourceIsFriend, u32 msgId)
{
bool32 wonderSuccess;
const u8 * str = GetServerResultMessage(&wonderSuccess, sourceIsFriend, msgId);
if (wonderSuccess)
return PrintSuccessMessage(state, str, timer);
else
return PrintMysteryGiftMenuMessage(state, str);
}
// 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(Task_MysteryGift, 0);
struct MysteryGiftTaskData * data = (void *)gTasks[taskId].data;
data->state = MG_STATE_TO_MAIN_MENU;
data->textState = 0;
data->unused4 = 0;
data->unused5 = 0;
data->isWonderNews = 0;
data->sourceIsFriend = 0;
data->var = 0;
data->unused1 = 0;
data->unused2 = 0;
data->unused3 = 0;
data->msgId = 0;
data->clientMsg = AllocZeroed(CLIENT_MAX_MSG_SIZE);
}
static void Task_MysteryGift(u8 taskId)
{
struct MysteryGiftTaskData *data = (void *)gTasks[taskId].data;
u32 successMsg, input;
const u8 *msg;
switch (data->state)
{
case MG_STATE_TO_MAIN_MENU:
data->state = MG_STATE_MAIN_MENU;
break;
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: // "Wonder Cards"
data->isWonderNews = FALSE;
if (ValidateSavedWonderCard() == TRUE)
data->state = MG_STATE_LOAD_GIFT;
else
data->state = MG_STATE_DONT_HAVE_ANY;
break;
case 1: // "Wonder News"
data->isWonderNews = TRUE;
if (ValidateSavedWonderNews() == TRUE)
data->state = MG_STATE_LOAD_GIFT;
else
data->state = MG_STATE_DONT_HAVE_ANY;
break;
case LIST_CANCEL:
data->state = MG_STATE_EXIT;
break;
}
break;
case MG_STATE_DONT_HAVE_ANY:
{
// 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 = MG_STATE_SOURCE_PROMPT;
PrintMysteryGiftOrEReaderTopMenu(FALSE, TRUE);
}
}
else
{
if (PrintMysteryGiftMenuMessage(&data->textState, gText_DontHaveNewsNewOneInput))
{
data->state = MG_STATE_SOURCE_PROMPT;
PrintMysteryGiftOrEReaderTopMenu(FALSE, TRUE);
}
}
break;
}
case MG_STATE_SOURCE_PROMPT:
if (!data->isWonderNews)
AddTextPrinterToWindow1(gText_WhereShouldCardBeAccessed);
else
AddTextPrinterToWindow1(gText_WhereShouldNewsBeAccessed);
data->state = MG_STATE_SOURCE_PROMPT_INPUT;
break;
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: // "Wireless Communication"
ClearTextWindow();
data->state = MG_STATE_CLIENT_LINK_START;
data->sourceIsFriend = FALSE;
break;
case 1: // "Friend"
ClearTextWindow();
data->state = MG_STATE_CLIENT_LINK_START;
data->sourceIsFriend = TRUE;
break;
case LIST_CANCEL:
ClearTextWindow();
if (ValidateCardOrNews(data->isWonderNews))
{
data->state = MG_STATE_LOAD_GIFT;
}
else
{
data->state = MG_STATE_TO_MAIN_MENU;
PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE);
}
break;
}
break;
case MG_STATE_CLIENT_LINK_START:
*gStringVar1 = EOS;
*gStringVar2 = EOS;
*gStringVar3 = EOS;
switch (data->isWonderNews)
{
case FALSE:
if (data->sourceIsFriend == TRUE)
CreateTask_LinkMysteryGiftWithFriend(ACTIVITY_WONDER_CARD);
else if (data->sourceIsFriend == FALSE)
CreateTask_LinkMysteryGiftOverWireless(ACTIVITY_WONDER_CARD);
break;
case TRUE:
if (data->sourceIsFriend == TRUE)
CreateTask_LinkMysteryGiftWithFriend(ACTIVITY_WONDER_NEWS);
else if (data->sourceIsFriend == FALSE)
CreateTask_LinkMysteryGiftOverWireless(ACTIVITY_WONDER_NEWS);
break;
}
data->state = MG_STATE_CLIENT_LINK_WAIT;
break;
case MG_STATE_CLIENT_LINK_WAIT:
if (gReceivedRemoteLinkPlayers != 0)
{
ClearScreenInBg0(TRUE);
data->state = MG_STATE_CLIENT_COMMUNICATING;
MysteryGiftClient_Create(data->isWonderNews);
}
else if (gSpecialVar_Result == LINKUP_FAILED)
{
// Link failed, return to link start menu
ClearScreenInBg0(TRUE);
data->state = MG_STATE_SOURCE_PROMPT;
}
break;
case MG_STATE_CLIENT_COMMUNICATING:
AddTextPrinterToWindow1(gText_Communicating);
data->state = MG_STATE_CLIENT_LINK;
break;
case MG_STATE_CLIENT_LINK:
switch (MysteryGiftClient_Run(&data->var))
{
case CLI_RET_END:
Rfu_SetCloseLinkCallback();
data->msgId = data->var;
data->state = MG_STATE_CLIENT_LINK_END;
break;
case CLI_RET_COPY_MSG:
memcpy(data->clientMsg, MysteryGiftClient_GetMsg(), 0x40);
MysteryGiftClient_AdvanceState();
break;
case CLI_RET_PRINT_MSG:
data->state = MG_STATE_CLIENT_MESSAGE;
break;
case CLI_RET_YES_NO:
data->state = MG_STATE_CLIENT_YES_NO;
break;
case CLI_RET_ASK_TOSS:
data->state = MG_STATE_CLIENT_ASK_TOSS;
StringCopy(gStringVar1, gLinkPlayers[0].name);
break;
}
break;
case MG_STATE_CLIENT_YES_NO:
input = DoMysteryGiftYesNo(&data->textState, &data->var, FALSE, MysteryGiftClient_GetMsg());
switch (input)
{
case 0: // Yes
MysteryGiftClient_SetParam(FALSE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
break;
case 1: // No
case MENU_B_PRESSED:
MysteryGiftClient_SetParam(TRUE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
break;
}
break;
case MG_STATE_CLIENT_MESSAGE:
if (PrintMysteryGiftMenuMessage(&data->textState, MysteryGiftClient_GetMsg()))
{
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
}
break;
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: // Yes
if (IsSavedWonderCardGiftNotReceived() == TRUE)
{
data->state = MG_STATE_CLIENT_ASK_TOSS_UNRECEIVED;
}
else
{
MysteryGiftClient_SetParam(FALSE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
}
break;
case 1: // No
case MENU_B_PRESSED:
MysteryGiftClient_SetParam(TRUE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
break;
}
break;
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: // Yes
MysteryGiftClient_SetParam(FALSE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
break;
case 1: // No
case MENU_B_PRESSED:
MysteryGiftClient_SetParam(TRUE);
MysteryGiftClient_AdvanceState();
data->state = MG_STATE_CLIENT_COMMUNICATING;
break;
}
break;
case MG_STATE_CLIENT_LINK_END:
if (gReceivedRemoteLinkPlayers == 0)
{
DestroyWirelessStatusIndicatorSprite();
data->state = MG_STATE_CLIENT_COMM_COMPLETED;
}
break;
case MG_STATE_CLIENT_COMM_COMPLETED:
if (PrintStringAndWait2Seconds(&data->textState, gText_CommunicationCompleted))
{
if (data->sourceIsFriend == TRUE)
StringCopy(gStringVar1, gLinkPlayers[0].name);
data->state = MG_STATE_CLIENT_RESULT_MSG;
}
break;
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
input = PrintMysteryGiftMenuMessage(&data->textState, msg);
// input var re-used, here it is TRUE if the message is finished
if (input)
{
if (data->msgId == CLI_MSG_NEWS_RECEIVED)
{
if (data->sourceIsFriend == TRUE)
GenerateRandomWonderNews(WONDER_NEWS_RECV_FRIEND);
else
GenerateRandomWonderNews(WONDER_NEWS_RECV_WIRELESS);
}
if (!successMsg)
{
// Did not receive card/news, return to main menu
data->state = MG_STATE_TO_MAIN_MENU;
PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE);
}
else
{
data->state = MG_STATE_SAVE_LOAD_GIFT;
}
}
break;
case MG_STATE_SAVE_LOAD_GIFT:
if (SaveOnMysteryGiftMenu(&data->textState))
data->state = MG_STATE_LOAD_GIFT;
break;
case MG_STATE_LOAD_GIFT:
if (HandleLoadWonderCardOrNews(&data->textState, data->isWonderNews))
data->state = MG_STATE_HANDLE_GIFT_INPUT;
break;
case MG_STATE_HANDLE_GIFT_INPUT:
if (!data->isWonderNews)
{
// Handle Wonder Card input
if (JOY_NEW(A_BUTTON))
data->state = MG_STATE_HANDLE_GIFT_SELECT;
if (JOY_NEW(B_BUTTON))
data->state = MG_STATE_GIFT_INPUT_EXIT;
}
else
{
switch (WonderNews_GetInput(gMain.newKeys))
{
case NEWS_INPUT_A:
WonderNews_RemoveScrollIndicatorArrowPair();
data->state = MG_STATE_HANDLE_GIFT_SELECT;
break;
case NEWS_INPUT_B:
data->state = MG_STATE_GIFT_INPUT_EXIT;
break;
}
}
break;
case MG_STATE_HANDLE_GIFT_SELECT:
{
// A Wonder Card/News has been selected, handle its menu
u32 result;
if (!data->isWonderNews)
{
if (IsSendingSavedWonderCardAllowed())
result = HandleGiftSelectMenu(&data->textState, &data->var, data->isWonderNews, FALSE);
else
result = HandleGiftSelectMenu(&data->textState, &data->var, data->isWonderNews, TRUE);
}
else
{
if (IsSendingSavedWonderNewsAllowed())
result = HandleGiftSelectMenu(&data->textState, &data->var, data->isWonderNews, FALSE);
else
result = HandleGiftSelectMenu(&data->textState, &data->var, data->isWonderNews, TRUE);
}
switch (result)
{
case 0: // Receive
data->state = MG_STATE_RECEIVE;
break;
case 1: // Send
data->state = MG_STATE_SEND;
break;
case 2: // Toss
data->state = MG_STATE_ASK_TOSS;
break;
case LIST_CANCEL:
if (data->isWonderNews == TRUE)
WonderNews_AddScrollIndicatorArrowPair();
data->state = MG_STATE_HANDLE_GIFT_INPUT;
break;
}
break;
}
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: // 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)
{
case FALSE:
CreateTask_SendMysteryGift(ACTIVITY_WONDER_CARD);
break;
case TRUE:
CreateTask_SendMysteryGift(ACTIVITY_WONDER_NEWS);
break;
}
data->sourceIsFriend = TRUE;
data->state = MG_STATE_SERVER_LINK_WAIT;
}
break;
case MG_STATE_SERVER_LINK_WAIT:
if (gReceivedRemoteLinkPlayers != 0)
{
ClearScreenInBg0(TRUE);
data->state = MG_STATE_SERVER_LINK_START;
}
else if (gSpecialVar_Result == LINKUP_FAILED)
{
ClearScreenInBg0(TRUE);
data->state = MG_STATE_LOAD_GIFT;
}
break;
case MG_STATE_SERVER_LINK_START:
*gStringVar1 = EOS;
*gStringVar2 = EOS;
*gStringVar3 = EOS;
if (!data->isWonderNews)
{
AddTextPrinterToWindow1(gText_SendingWonderCard);
MysterGiftServer_CreateForCard();
}
else
{
AddTextPrinterToWindow1(gText_SendingWonderNews);
MysterGiftServer_CreateForNews();
}
data->state = MG_STATE_SERVER_LINK;
break;
case MG_STATE_SERVER_LINK:
if (MysterGiftServer_Run(&data->var) == SVR_RET_END)
{
data->msgId = data->var;
data->state = MG_STATE_SERVER_LINK_END;
}
break;
case MG_STATE_SERVER_LINK_END:
Rfu_SetCloseLinkCallback();
StringCopy(gStringVar1, gLinkPlayers[1].name);
data->state = MG_STATE_SERVER_LINK_END_WAIT;
break;
case MG_STATE_SERVER_LINK_END_WAIT:
if (gReceivedRemoteLinkPlayers == 0)
{
DestroyWirelessStatusIndicatorSprite();
data->state = MG_STATE_SERVER_RESULT_MSG;
}
break;
case MG_STATE_SERVER_RESULT_MSG:
if (PrintServerResultMessage(&data->textState, &data->var, data->sourceIsFriend, data->msgId))
{
if (data->sourceIsFriend == TRUE && data->msgId == SVR_MSG_NEWS_SENT)
{
GenerateRandomWonderNews(WONDER_NEWS_SENT);
data->state = MG_STATE_SAVE_LOAD_GIFT;
}
else
{
data->state = MG_STATE_TO_MAIN_MENU;
PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE);
}
}
break;
case MG_STATE_CLIENT_ERROR:
case MG_STATE_SERVER_ERROR:
if (PrintMysteryGiftMenuMessage(&data->textState, gText_CommunicationError))
{
data->state = MG_STATE_TO_MAIN_MENU;
PrintMysteryGiftOrEReaderTopMenu(FALSE, FALSE);
}
break;
case MG_STATE_EXIT:
CloseLink();
Free(data->clientMsg);
DestroyTask(taskId);
SetMainCallback2(MainCB_FreeAllBuffersAndReturnToInitTitleScreen);
break;
}
}
u16 GetMysteryGiftBaseBlock(void)
{
return 0x1A9;
}
static void LoadMysteryGiftTextboxBorder(u8 bgId)
{
DecompressAndLoadBgGfxUsingHeap(bgId, sTextboxBorder_Gfx, 0x100, 0, 0);
}