tumbledemerald-legacy/src/pokenav_match_call_list.c

522 lines
15 KiB
C
Raw Normal View History

2022-05-19 19:14:13 +02:00
#include "global.h"
#include "battle_setup.h"
#include "data.h"
#include "event_data.h"
#include "gym_leader_rematch.h"
#include "international_string_util.h"
#include "main.h"
#include "match_call.h"
#include "overworld.h"
#include "pokemon.h"
#include "pokenav.h"
#include "sound.h"
#include "string_util.h"
#include "strings.h"
#include "constants/songs.h"
struct Pokenav_MatchCallMenu
{
u16 optionCursorPos;
u16 maxOptionId;
const u8 *matchCallOptions;
u16 headerId;
u16 numRegistered;
u16 numSpecialTrainers;
bool32 initFinished;
u32 loopedTaskId;
u32 (*callback)(struct Pokenav_MatchCallMenu*);
struct PokenavMatchCallEntry matchCallEntries[MAX_REMATCH_ENTRIES - 1];
};
static u32 CB2_HandleMatchCallInput(struct Pokenav_MatchCallMenu *);
static u32 GetExitMatchCallMenuId(struct Pokenav_MatchCallMenu *);
static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav_MatchCallMenu *);
static u32 CB2_HandleCheckPageInput(struct Pokenav_MatchCallMenu *);
static u32 CB2_HandleCallExitInput(struct Pokenav_MatchCallMenu *);
static u32 LoopedTask_BuildMatchCallList(s32);
static bool32 ShouldDoNearbyMessage(void);
#include "data/text/match_call_messages.h"
static const u8 sMatchCallOptionsNoCheckPage[] =
{
MATCH_CALL_OPTION_CALL,
MATCH_CALL_OPTION_CANCEL
};
static const u8 sMatchCallOptionsHasCheckPage[] =
{
MATCH_CALL_OPTION_CALL,
MATCH_CALL_OPTION_CHECK,
MATCH_CALL_OPTION_CANCEL
};
bool32 PokenavCallback_Init_MatchCall(void)
{
struct Pokenav_MatchCallMenu *state = AllocSubstruct(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN, sizeof(struct Pokenav_MatchCallMenu));
if (!state)
return FALSE;
state->callback = CB2_HandleMatchCallInput;
state->headerId = 0;
state->initFinished = FALSE;
state->loopedTaskId = CreateLoopedTask(LoopedTask_BuildMatchCallList, 1);
return TRUE;
}
u32 GetMatchCallCallback(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->callback(state);
}
void FreeMatchCallSubstruct1(void)
{
FreePokenavSubstruct(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
}
static u32 CB2_HandleMatchCallInput(struct Pokenav_MatchCallMenu *state)
{
int selection;
if (JOY_REPEAT(DPAD_UP))
return POKENAV_MC_FUNC_UP;
if (JOY_REPEAT(DPAD_DOWN))
return POKENAV_MC_FUNC_DOWN;
if (JOY_REPEAT(DPAD_LEFT))
return POKENAV_MC_FUNC_PG_UP;
if (JOY_REPEAT(DPAD_RIGHT))
return POKENAV_MC_FUNC_PG_DOWN;
if (JOY_NEW(A_BUTTON))
{
state->callback = CB2_HandleMatchCallOptionsInput;
state->optionCursorPos = 0;
selection = PokenavList_GetSelectedIndex();
if (!state->matchCallEntries[selection].isSpecialTrainer || MatchCall_HasCheckPage(state->matchCallEntries[selection].headerId))
{
state->matchCallOptions = sMatchCallOptionsHasCheckPage;
state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsHasCheckPage) - 1;
}
else
{
state->matchCallOptions = sMatchCallOptionsNoCheckPage;
state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsNoCheckPage) - 1;
}
return POKENAV_MC_FUNC_SELECT;
}
if (JOY_NEW(B_BUTTON))
{
if (GetPokenavMode() != POKENAV_MODE_FORCE_CALL_READY)
{
state->callback = GetExitMatchCallMenuId;
return POKENAV_MC_FUNC_EXIT;
}
else
{
// Cant exit Match Call menu before calling Mr Stone during tutorial
PlaySE(SE_FAILURE);
}
}
return POKENAV_MC_FUNC_NONE;
}
static u32 GetExitMatchCallMenuId(struct Pokenav_MatchCallMenu *state)
{
return POKENAV_MAIN_MENU_CURSOR_ON_MATCH_CALL;
}
static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav_MatchCallMenu *state)
{
if (JOY_NEW(DPAD_UP) && state->optionCursorPos)
{
state->optionCursorPos--;
return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR;
}
if (JOY_NEW(DPAD_DOWN) && state->optionCursorPos < state->maxOptionId)
{
state->optionCursorPos++;
return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR;
}
if (JOY_NEW(A_BUTTON))
{
switch (state->matchCallOptions[state->optionCursorPos])
{
case MATCH_CALL_OPTION_CANCEL:
state->callback = CB2_HandleMatchCallInput;
return POKENAV_MC_FUNC_CANCEL;
case MATCH_CALL_OPTION_CALL:
if (GetPokenavMode() == POKENAV_MODE_FORCE_CALL_READY)
SetPokenavMode(POKENAV_MODE_FORCE_CALL_EXIT);
state->callback = CB2_HandleCallExitInput;
if (ShouldDoNearbyMessage())
return POKENAV_MC_FUNC_NEARBY_MSG;
return POKENAV_MC_FUNC_CALL_MSG;
case MATCH_CALL_OPTION_CHECK:
state->callback = CB2_HandleCheckPageInput;
return POKENAV_MC_FUNC_SHOW_CHECK_PAGE;
}
}
if (JOY_NEW(B_BUTTON))
{
state->callback = CB2_HandleMatchCallInput;
return POKENAV_MC_FUNC_CANCEL;
}
return POKENAV_MC_FUNC_NONE;
}
static u32 CB2_HandleCheckPageInput(struct Pokenav_MatchCallMenu *state)
{
if (JOY_REPEAT(DPAD_UP))
return POKENAV_MC_FUNC_CHECK_PAGE_UP;
if (JOY_REPEAT(DPAD_DOWN))
return POKENAV_MC_FUNC_CHECK_PAGE_DOWN;
if (JOY_NEW(B_BUTTON))
{
state->callback = CB2_HandleMatchCallInput;
return POKENAV_MC_FUNC_EXIT_CHECK_PAGE;
}
return POKENAV_MC_FUNC_NONE;
}
static u32 CB2_HandleCallExitInput(struct Pokenav_MatchCallMenu *state)
{
if (JOY_NEW(A_BUTTON | B_BUTTON))
{
state->callback = CB2_HandleMatchCallInput;
return POKENAV_MC_FUNC_EXIT_CALL;
}
return POKENAV_MC_FUNC_NONE;
}
static u32 LoopedTask_BuildMatchCallList(s32 taskState)
{
int i, j;
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
switch (taskState)
{
case 0:
state->headerId = 0;
state->numRegistered = 0;
return LT_INC_AND_CONTINUE;
case 1:
// Load special trainers (e.g. Rival, gym leaders)
for (i = 0, j = state->headerId; i < 30; i++, j++)
{
if (MatchCall_GetEnabled(j))
{
state->matchCallEntries[state->numRegistered].headerId = j;
state->matchCallEntries[state->numRegistered].isSpecialTrainer = TRUE;
state->matchCallEntries[state->numRegistered].mapSec = MatchCall_GetMapSec(j);
state->numRegistered++;
}
if (++state->headerId >= MC_HEADER_COUNT)
{
state->numSpecialTrainers = state->headerId;
state->headerId = 0;
return LT_INC_AND_CONTINUE;
}
}
return LT_CONTINUE;
case 2:
// Load normal trainers
for (i = 0, j = state->headerId; i < 30; i++, j++)
{
if (!MatchCall_HasRematchId(state->headerId) && IsRematchEntryRegistered(state->headerId))
{
state->matchCallEntries[state->numRegistered].headerId = state->headerId;
state->matchCallEntries[state->numRegistered].isSpecialTrainer = FALSE;
state->matchCallEntries[state->numRegistered].mapSec = GetMatchTableMapSectionId(j);
state->numRegistered++;
}
if (++state->headerId > REMATCH_TABLE_ENTRIES - 1)
return LT_INC_AND_CONTINUE;
}
return LT_CONTINUE;
case 3:
state->initFinished = TRUE;
break;
}
return LT_FINISH;
}
bool32 IsRematchEntryRegistered(int rematchIndex)
{
if (rematchIndex < REMATCH_TABLE_ENTRIES)
return FlagGet(FLAG_MATCH_CALL_REGISTERED + rematchIndex);
return FALSE;
}
int IsMatchCallListInitFinished(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->initFinished;
}
int GetNumberRegistered(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->numRegistered;
}
// Unused
static int GetNumSpecialTrainers(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->numSpecialTrainers;
}
// Unused
static int GetNumNormalTrainers(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->numRegistered - state->numSpecialTrainers;
}
// Unused
static int GetNormalTrainerHeaderId(int index)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
index += state->numSpecialTrainers;
if (index >= state->numRegistered)
return REMATCH_TABLE_ENTRIES;
return state->matchCallEntries[index].headerId;
}
struct PokenavMatchCallEntry *GetMatchCallList(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->matchCallEntries;
}
u16 GetMatchCallMapSec(int index)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->matchCallEntries[index].mapSec;
}
bool32 ShouldDrawRematchPokeballIcon(int index)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
if (!state->matchCallEntries[index].isSpecialTrainer)
index = state->matchCallEntries[index].headerId;
else
index = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId);
if (index == REMATCH_TABLE_ENTRIES)
return FALSE;
return gSaveBlock1Ptr->trainerRematches[index] != 0;
}
int GetMatchCallTrainerPic(int index)
{
int headerId;
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
if (!state->matchCallEntries[index].isSpecialTrainer)
{
index = GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId);
return gTrainers[index].trainerPic;
}
headerId = state->matchCallEntries[index].headerId;
index = MatchCall_GetRematchTableIdx(headerId);
if (index != REMATCH_TABLE_ENTRIES)
{
index = GetTrainerIdxByRematchIdx(index);
return gTrainers[index].trainerPic;
}
index = MatchCall_GetOverrideFacilityClass(headerId);
return gFacilityClassToPicIndex[index];
}
const u8 *GetMatchCallMessageText(int index, bool8 *newRematchRequest)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
*newRematchRequest = FALSE;
if (!Overworld_MapTypeAllowsTeleportAndFly(gMapHeader.mapType))
return gText_CallCantBeMadeHere;
if (!state->matchCallEntries[index].isSpecialTrainer)
*newRematchRequest = SelectMatchCallMessage(GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId), gStringVar4);
else
MatchCall_GetMessage(state->matchCallEntries[index].headerId, gStringVar4);
return gStringVar4;
}
const u8 *GetMatchCallFlavorText(int index, int checkPageEntry)
{
int rematchId;
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
if (state->matchCallEntries[index].isSpecialTrainer)
{
rematchId = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId);
if (rematchId == REMATCH_TABLE_ENTRIES)
return MatchCall_GetOverrideFlavorText(state->matchCallEntries[index].headerId, checkPageEntry);
}
else
{
rematchId = state->matchCallEntries[index].headerId;
}
return gMatchCallFlavorTexts[rematchId][checkPageEntry];
}
u16 GetMatchCallOptionCursorPos(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
return state->optionCursorPos;
}
u16 GetMatchCallOptionId(int optionId)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
if (state->maxOptionId < optionId)
return MATCH_CALL_OPTION_COUNT;
return state->matchCallOptions[optionId];
}
void BufferMatchCallNameAndDesc(struct PokenavMatchCallEntry *matchCallEntry, u8 *str)
{
const u8 *trainerName;
const u8 *className;
if (!matchCallEntry->isSpecialTrainer)
{
int index = GetTrainerIdxByRematchIdx(matchCallEntry->headerId);
const struct Trainer *trainer = &gTrainers[index];
int class = trainer->trainerClass;
className = gTrainerClassNames[class];
trainerName = trainer->trainerName;
}
else
{
MatchCall_GetNameAndDesc(matchCallEntry->headerId, &className, &trainerName);
}
if (className && trainerName)
{
u8 *str2 = GetStringClearToWidth(str, FONT_NARROW, className, 69);
GetStringClearToWidth(str2, FONT_NARROW, trainerName, 51);
}
else
{
GetStringClearToWidth(str, FONT_NARROW, NULL, 120);
}
}
u8 GetMatchTableMapSectionId(int rematchIndex)
{
int mapGroup = gRematchTable[rematchIndex].mapGroup;
int mapNum = gRematchTable[rematchIndex].mapNum;
return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->regionMapSectionId;
}
int GetIndexDeltaOfNextCheckPageDown(int index)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
int count = 1;
while (++index < state->numRegistered)
{
if (!state->matchCallEntries[index].isSpecialTrainer)
return count;
if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId))
return count;
count++;
}
return 0;
}
int GetIndexDeltaOfNextCheckPageUp(int index)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
int count = -1;
while (--index >= 0)
{
if (!state->matchCallEntries[index].isSpecialTrainer)
return count;
if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId))
return count;
count--;
}
return 0;
}
// Unused
static bool32 HasRematchEntry(void)
{
int i;
for (i = 0; i < REMATCH_TABLE_ENTRIES; i++)
{
if (IsRematchEntryRegistered(i) && gSaveBlock1Ptr->trainerRematches[i])
return TRUE;
}
for (i = 0; i < MC_HEADER_COUNT; i++)
{
if (MatchCall_GetEnabled(i))
{
int index = MatchCall_GetRematchTableIdx(i);
if (gSaveBlock1Ptr->trainerRematches[index])
return TRUE;
}
}
return FALSE;
}
static bool32 ShouldDoNearbyMessage(void)
{
struct Pokenav_MatchCallMenu *state = GetSubstructPtr(POKENAV_SUBSTRUCT_MATCH_CALL_MAIN);
int selection = PokenavList_GetSelectedIndex();
if (!state->matchCallEntries[selection].isSpecialTrainer)
{
if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId)
{
if (!gSaveBlock1Ptr->trainerRematches[state->matchCallEntries[selection].headerId])
return TRUE;
}
}
else
{
if (state->matchCallEntries[selection].headerId == MC_HEADER_WATTSON)
{
if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId
&& FlagGet(FLAG_BADGE05_GET) == TRUE)
{
if (!FlagGet(FLAG_WATTSON_REMATCH_AVAILABLE))
return TRUE;
}
}
}
return FALSE;
}