tbld/tumbledemerald-legacy
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 5 Wiki Activity
3c53a7dca0
tumbledemerald-legacy/src/secret_base.c

2073 lines
70 KiB
C
Raw Normal View History

import from github
2022-05-19 19:14:13 +02:00
#include "global.h"
#include "malloc.h"
#include "battle.h"
#include "battle_setup.h"
#include "decoration.h"
#include "event_data.h"
#include "event_object_movement.h"
#include "event_scripts.h"
#include "field_camera.h"
#include "field_effect.h"
#include "field_player_avatar.h"
#include "field_screen_effect.h"
#include "field_specials.h"
#include "field_weather.h"
#include "fieldmap.h"
#include "fldeff.h"
#include "fldeff_misc.h"
#include "international_string_util.h"
#include "item_menu.h"
#include "link.h"
#include "list_menu.h"
#include "main.h"
#include "map_name_popup.h"
#include "menu.h"
#include "menu_helpers.h"
#include "metatile_behavior.h"
#include "overworld.h"
#include "palette.h"
#include "script.h"
#include "secret_base.h"
#include "sound.h"
#include "string_util.h"
#include "strings.h"
#include "task.h"
#include "tv.h"
#include "window.h"
#include "constants/event_bg.h"
#include "constants/decorations.h"
#include "constants/event_objects.h"
#include "constants/field_specials.h"
#include "constants/items.h"
#include "constants/map_types.h"
#include "constants/metatile_behaviors.h"
#include "constants/metatile_labels.h"
#include "constants/moves.h"
#include "constants/secret_bases.h"
#include "constants/songs.h"
#include "constants/trainers.h"
// Values for registryStatus
enum {
UNREGISTERED,
REGISTERED,
NEW, // Temporary, so new secret bases mixed at the same time don't overwrite each other
};
struct SecretBaseRegistryMenu
{
struct ListMenuItem items[11];
u8 names[11][32];
};
struct SecretBaseRecordMixer
{
struct SecretBase *secretBases;
u32 version;
u32 language;
};
struct SecretBaseEntranceMetatiles
{
u16 closedMetatileId;
u16 openMetatileId;
};
static EWRAM_DATA u8 sCurSecretBaseId = 0;
static EWRAM_DATA bool8 sInFriendSecretBase = FALSE;
static EWRAM_DATA struct SecretBaseRegistryMenu *sRegistryMenu = NULL;
static void Task_ShowSecretBaseRegistryMenu(u8);
static void BuildRegistryMenuItems(u8);
static void RegistryMenu_OnCursorMove(s32, bool8, struct ListMenu *);
static void FinalizeRegistryMenu(u8);
static void AddRegistryMenuScrollArrows(u8);
static void HandleRegistryMenuInput(u8);
static void ShowRegistryMenuActions(u8);
static void HandleRegistryMenuActionsInput(u8);
static void ShowRegistryMenuDeleteConfirmation(u8);
static void ShowRegistryMenuDeleteYesNo(u8);
static void DeleteRegistry_Yes(u8);
static void DeleteRegistry_No(u8);
static void ReturnToMainRegistryMenu(u8);
static void GoToSecretBasePCRegisterMenu(u8);
static u8 GetSecretBaseOwnerType(u8);
static const struct SecretBaseEntranceMetatiles sSecretBaseEntranceMetatiles[] =
{
{.closedMetatileId = METATILE_General_SecretBase_TreeLeft, .openMetatileId = METATILE_General_SecretBase_VineLeft},
{.closedMetatileId = METATILE_General_SecretBase_TreeRight, .openMetatileId = METATILE_General_SecretBase_VineRight},
{.closedMetatileId = METATILE_General_RedCaveIndent, .openMetatileId = METATILE_General_RedCaveOpen},
{.closedMetatileId = METATILE_General_YellowCaveIndent, .openMetatileId = METATILE_General_YellowCaveOpen},
{.closedMetatileId = METATILE_General_BlueCaveIndent, .openMetatileId = METATILE_General_BlueCaveOpen},
{.closedMetatileId = METATILE_Fallarbor_BrownCaveIndent, .openMetatileId = METATILE_Fallarbor_BrownCaveOpen},
{.closedMetatileId = METATILE_Fortree_SecretBase_Shrub, .openMetatileId = METATILE_Fortree_SecretBase_ShrubOpen},
};
// mapNum, warpId, x, y
// x, y positions are for when the player warps in for the first time (in front of the computer)
static const u8 sSecretBaseEntrancePositions[NUM_SECRET_BASE_GROUPS * 4] =
{
[SECRET_BASE_RED_CAVE1] = MAP_NUM(SECRET_BASE_RED_CAVE1), 0, 1, 3,
[SECRET_BASE_RED_CAVE2] = MAP_NUM(SECRET_BASE_RED_CAVE2), 0, 5, 9,
[SECRET_BASE_RED_CAVE3] = MAP_NUM(SECRET_BASE_RED_CAVE3), 0, 1, 3,
[SECRET_BASE_RED_CAVE4] = MAP_NUM(SECRET_BASE_RED_CAVE4), 0, 7, 13,
[SECRET_BASE_BROWN_CAVE1] = MAP_NUM(SECRET_BASE_BROWN_CAVE1), 0, 2, 3,
[SECRET_BASE_BROWN_CAVE2] = MAP_NUM(SECRET_BASE_BROWN_CAVE2), 0, 9, 2,
[SECRET_BASE_BROWN_CAVE3] = MAP_NUM(SECRET_BASE_BROWN_CAVE3), 0, 13, 4,
[SECRET_BASE_BROWN_CAVE4] = MAP_NUM(SECRET_BASE_BROWN_CAVE4), 0, 1, 2,
[SECRET_BASE_BLUE_CAVE1] = MAP_NUM(SECRET_BASE_BLUE_CAVE1), 0, 1, 3,
[SECRET_BASE_BLUE_CAVE2] = MAP_NUM(SECRET_BASE_BLUE_CAVE2), 0, 1, 2,
[SECRET_BASE_BLUE_CAVE3] = MAP_NUM(SECRET_BASE_BLUE_CAVE3), 0, 3, 15,
[SECRET_BASE_BLUE_CAVE4] = MAP_NUM(SECRET_BASE_BLUE_CAVE4), 0, 3, 14,
[SECRET_BASE_YELLOW_CAVE1] = MAP_NUM(SECRET_BASE_YELLOW_CAVE1), 0, 9, 3,
[SECRET_BASE_YELLOW_CAVE2] = MAP_NUM(SECRET_BASE_YELLOW_CAVE2), 0, 8, 7,
[SECRET_BASE_YELLOW_CAVE3] = MAP_NUM(SECRET_BASE_YELLOW_CAVE3), 0, 3, 6,
[SECRET_BASE_YELLOW_CAVE4] = MAP_NUM(SECRET_BASE_YELLOW_CAVE4), 0, 5, 9,
[SECRET_BASE_TREE1] = MAP_NUM(SECRET_BASE_TREE1), 0, 2, 3,
[SECRET_BASE_TREE2] = MAP_NUM(SECRET_BASE_TREE2), 0, 5, 6,
[SECRET_BASE_TREE3] = MAP_NUM(SECRET_BASE_TREE3), 0, 15, 3,
[SECRET_BASE_TREE4] = MAP_NUM(SECRET_BASE_TREE4), 0, 4, 10,
[SECRET_BASE_SHRUB1] = MAP_NUM(SECRET_BASE_SHRUB1), 0, 3, 3,
[SECRET_BASE_SHRUB2] = MAP_NUM(SECRET_BASE_SHRUB2), 0, 1, 2,
[SECRET_BASE_SHRUB3] = MAP_NUM(SECRET_BASE_SHRUB3), 0, 7, 8,
[SECRET_BASE_SHRUB4] = MAP_NUM(SECRET_BASE_SHRUB4), 0, 9, 6,
};
#define GET_BASE_MAP_NUM(group) (sSecretBaseEntrancePositions[(group) + 0])
#define GET_BASE_WARP_ID(group) (sSecretBaseEntrancePositions[(group) + 1])
#define GET_BASE_COMPUTER_X(group) (sSecretBaseEntrancePositions[(group) + 2])
#define GET_BASE_COMPUTER_Y(group) (sSecretBaseEntrancePositions[(group) + 3])
static const struct MenuAction sRegistryMenuActions[] =
{
{
.text = gText_DelRegist,
.func = { .void_u8 = ShowRegistryMenuDeleteConfirmation },
},
{
.text = gText_Cancel,
.func = { .void_u8 = ReturnToMainRegistryMenu },
},
};
static const struct YesNoFuncTable sDeleteRegistryYesNoFuncs =
{
.yesFunc = DeleteRegistry_Yes,
.noFunc = DeleteRegistry_No,
};
static const u8 sSecretBaseOwnerGfxIds[10] =
{
// Male
OBJ_EVENT_GFX_YOUNGSTER,
OBJ_EVENT_GFX_BUG_CATCHER,
OBJ_EVENT_GFX_RICH_BOY,
OBJ_EVENT_GFX_CAMPER,
OBJ_EVENT_GFX_MAN_3,
// Female
OBJ_EVENT_GFX_LASS,
OBJ_EVENT_GFX_GIRL_3,
OBJ_EVENT_GFX_WOMAN_2,
OBJ_EVENT_GFX_PICNICKER,
OBJ_EVENT_GFX_WOMAN_5,
};
static const struct WindowTemplate sRegistryWindowTemplates[] =
{
{
.bg = 0,
.tilemapLeft = 18,
.tilemapTop = 1,
.width = 11,
.height = 18,
.paletteNum = 15,
.baseBlock = 0x01,
},
{
.bg = 0,
.tilemapLeft = 2,
.tilemapTop = 1,
.width = 28,
.height = 4,
.paletteNum = 15,
.baseBlock = 0xc7,
}
};
static const struct ListMenuTemplate sRegistryListMenuTemplate =
{
.items = NULL,
.moveCursorFunc = RegistryMenu_OnCursorMove,
.itemPrintFunc = NULL,
.totalItems = 0,
.maxShowed = 0,
.windowId = 0,
.header_X = 0,
.item_X = 8,
.cursor_X = 0,
.upText_Y = 9,
.cursorPal = 2,
.fillValue = 1,
.cursorShadowPal = 3,
.lettersSpacing = 0,
.itemVerticalPadding = 0,
.scrollMultiple = LIST_NO_MULTIPLE_SCROLL,
.fontId = FONT_NORMAL,
.cursorKind = 0,
};
static void ClearSecretBase(struct SecretBase *secretBase)
{
u16 i;
CpuFastFill16(0, secretBase, sizeof(struct SecretBase));
for (i = 0; i < PLAYER_NAME_LENGTH; i++)
secretBase->trainerName[i] = EOS;
}
void ClearSecretBases(void)
{
u16 i;
for (i = 0; i < SECRET_BASES_COUNT; i++)
ClearSecretBase(&gSaveBlock1Ptr->secretBases[i]);
}
static void SetCurSecretBaseId(void)
{
sCurSecretBaseId = gSpecialVar_0x8004;
}
void TrySetCurSecretBaseIndex(void)
{
u16 i;
gSpecialVar_Result = FALSE;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (sCurSecretBaseId == gSaveBlock1Ptr->secretBases[i].secretBaseId)
{
gSpecialVar_Result = TRUE;
VarSet(VAR_CURRENT_SECRET_BASE, i);
break;
}
}
}
void CheckPlayerHasSecretBase(void)
{
// The player's secret base is always the first in the array.
if (gSaveBlock1Ptr->secretBases[0].secretBaseId)
gSpecialVar_Result = TRUE;
else
gSpecialVar_Result = FALSE;
}
static u8 GetSecretBaseTypeInFrontOfPlayer_(void)
{
s16 x, y;
s16 behavior;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
behavior = MapGridGetMetatileBehaviorAt(x, y) & 0xFFF;
if (behavior == MB_SECRET_BASE_SPOT_RED_CAVE || behavior == MB_SECRET_BASE_SPOT_RED_CAVE_OPEN)
return SECRET_BASE_RED_CAVE;
if (behavior == MB_SECRET_BASE_SPOT_BROWN_CAVE || behavior == MB_SECRET_BASE_SPOT_BROWN_CAVE_OPEN)
return SECRET_BASE_BROWN_CAVE;
if (behavior == MB_SECRET_BASE_SPOT_BLUE_CAVE || behavior == MB_SECRET_BASE_SPOT_BLUE_CAVE_OPEN)
return SECRET_BASE_BLUE_CAVE;
if (behavior == MB_SECRET_BASE_SPOT_YELLOW_CAVE || behavior == MB_SECRET_BASE_SPOT_YELLOW_CAVE_OPEN)
return SECRET_BASE_YELLOW_CAVE;
if (behavior == MB_SECRET_BASE_SPOT_TREE_LEFT || behavior == MB_SECRET_BASE_SPOT_TREE_LEFT_OPEN
|| behavior == MB_SECRET_BASE_SPOT_TREE_RIGHT || behavior == MB_SECRET_BASE_SPOT_TREE_RIGHT_OPEN)
return SECRET_BASE_TREE;
if (behavior == MB_SECRET_BASE_SPOT_SHRUB || behavior == MB_SECRET_BASE_SPOT_SHRUB_OPEN)
return SECRET_BASE_SHRUB;
return 0;
}
void GetSecretBaseTypeInFrontOfPlayer(void)
{
gSpecialVar_0x8007 = GetSecretBaseTypeInFrontOfPlayer_();
}
static void FindMetatileIdMapCoords(s16 *x, s16 *y, u16 metatileId)
{
s16 i, j;
const struct MapLayout *mapLayout = gMapHeader.mapLayout;
for (j = 0; j < mapLayout->height; j++)
{
for (i = 0; i < mapLayout->width; i++)
{
if ((mapLayout->map[j * mapLayout->width + i] & METATILE_ID_MASK) == metatileId)
{
*x = i;
*y = j;
return;
}
}
}
}
// Opens or closes the secret base entrance metatile in front of the player.
void ToggleSecretBaseEntranceMetatile(void)
{
u16 i;
s16 x, y;
s16 metatileId;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
metatileId = MapGridGetMetatileIdAt(x, y);
// Look for entrance metatiles to open
for (i = 0; i < ARRAY_COUNT(sSecretBaseEntranceMetatiles); i++)
{
if (sSecretBaseEntranceMetatiles[i].closedMetatileId == metatileId)
{
MapGridSetMetatileIdAt(x, y, sSecretBaseEntranceMetatiles[i].openMetatileId | METATILE_COLLISION_MASK);
CurrentMapDrawMetatileAt(x, y);
return;
}
}
// Look for entrance metatiles to close
for (i = 0; i < ARRAY_COUNT(sSecretBaseEntranceMetatiles); i++)
{
if (sSecretBaseEntranceMetatiles[i].openMetatileId == metatileId)
{
MapGridSetMetatileIdAt(x, y, sSecretBaseEntranceMetatiles[i].closedMetatileId | METATILE_COLLISION_MASK);
CurrentMapDrawMetatileAt(x, y);
return;
}
}
}
static u8 GetNameLength(const u8 *secretBaseOwnerName)
{
u8 i;
for (i = 0; i < PLAYER_NAME_LENGTH; i++)
{
if (secretBaseOwnerName[i] == EOS)
return i;
}
return PLAYER_NAME_LENGTH;
}
void SetPlayerSecretBase(void)
{
u16 i;
gSaveBlock1Ptr->secretBases[0].secretBaseId = sCurSecretBaseId;
for (i = 0; i < TRAINER_ID_LENGTH; i++)
gSaveBlock1Ptr->secretBases[0].trainerId[i] = gSaveBlock2Ptr->playerTrainerId[i];
VarSet(VAR_CURRENT_SECRET_BASE, 0);
StringCopyN(gSaveBlock1Ptr->secretBases[0].trainerName, gSaveBlock2Ptr->playerName, GetNameLength(gSaveBlock2Ptr->playerName));
gSaveBlock1Ptr->secretBases[0].gender = gSaveBlock2Ptr->playerGender;
gSaveBlock1Ptr->secretBases[0].language = GAME_LANGUAGE;
VarSet(VAR_SECRET_BASE_MAP, gMapHeader.regionMapSectionId);
}
// Set the 'open' entrance metatile for any occupied secret base on this map
void SetOccupiedSecretBaseEntranceMetatiles(struct MapEvents const *events)
{
u16 bgId;
u16 i, j;
for (bgId = 0; bgId < events->bgEventCount; bgId++)
{
if (events->bgEvents[bgId].kind == BG_EVENT_SECRET_BASE)
{
for (j = 0; j < SECRET_BASES_COUNT; j++)
{
if (gSaveBlock1Ptr->secretBases[j].secretBaseId == events->bgEvents[bgId].bgUnion.secretBaseId)
{
s16 x = events->bgEvents[bgId].x + MAP_OFFSET;
s16 y = events->bgEvents[bgId].y + MAP_OFFSET;
s16 tile_id = MapGridGetMetatileIdAt(x, y);
for (i = 0; i < ARRAY_COUNT(sSecretBaseEntranceMetatiles); i++)
{
if (sSecretBaseEntranceMetatiles[i].closedMetatileId == tile_id)
{
MapGridSetMetatileIdAt(x, y, sSecretBaseEntranceMetatiles[i].openMetatileId | METATILE_COLLISION_MASK);
break;
}
}
break;
}
}
}
}
}
static void SetSecretBaseWarpDestination(void)
{
s8 secretBaseGroup = SECRET_BASE_ID_TO_GROUP(sCurSecretBaseId);
SetWarpDestinationToMapWarp(MAP_GROUP(SECRET_BASE_RED_CAVE1), GET_BASE_MAP_NUM(secretBaseGroup), GET_BASE_WARP_ID(secretBaseGroup));
}
#define tState data[0]
static void Task_EnterSecretBase(u8 taskId)
{
u16 secretBaseIdx;
switch (gTasks[taskId].tState)
{
case 0:
if (!gPaletteFade.active)
gTasks[taskId].tState = 1;
break;
case 1:
secretBaseIdx = VarGet(VAR_CURRENT_SECRET_BASE);
if (gSaveBlock1Ptr->secretBases[secretBaseIdx].numTimesEntered < 255)
gSaveBlock1Ptr->secretBases[secretBaseIdx].numTimesEntered++;
SetSecretBaseWarpDestination();
WarpIntoMap();
gFieldCallback = FieldCB_ContinueScriptHandleMusic;
SetMainCallback2(CB2_LoadMap);
DestroyTask(taskId);
break;
}
}
#undef tState
void EnterSecretBase(void)
{
CreateTask(Task_EnterSecretBase, 0);
FadeScreen(FADE_TO_BLACK, 0);
SetDynamicWarp(0, gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, WARP_ID_NONE);
}
bool8 SecretBaseMapPopupEnabled(void)
{
if (gMapHeader.mapType == MAP_TYPE_SECRET_BASE && VarGet(VAR_INIT_SECRET_BASE) == 0)
return FALSE;
return TRUE;
}
static void EnterNewlyCreatedSecretBase_WaitFadeIn(u8 taskId)
{
ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], DIR_NORTH);
if (IsWeatherNotFadingIn() == TRUE)
{
EnableBothScriptContexts();
DestroyTask(taskId);
}
}
static void EnterNewlyCreatedSecretBase_StartFadeIn(void)
{
s16 x, y;
ScriptContext2_Enable();
HideMapNamePopUpWindow();
FindMetatileIdMapCoords(&x, &y, METATILE_SecretBase_PC);
x += MAP_OFFSET;
y += MAP_OFFSET;
MapGridSetMetatileIdAt(x, y, METATILE_SecretBase_PC | METATILE_COLLISION_MASK);
CurrentMapDrawMetatileAt(x, y);
FadeInFromBlack();
CreateTask(EnterNewlyCreatedSecretBase_WaitFadeIn, 0);
}
static void Task_EnterNewlyCreatedSecretBase(u8 taskId)
{
if (!gPaletteFade.active)
{
s8 secretBaseGroup = SECRET_BASE_ID_TO_GROUP(sCurSecretBaseId);
SetWarpDestination(
gSaveBlock1Ptr->location.mapGroup,
gSaveBlock1Ptr->location.mapNum,
WARP_ID_NONE,
GET_BASE_COMPUTER_X(secretBaseGroup),
GET_BASE_COMPUTER_Y(secretBaseGroup));
WarpIntoMap();
gFieldCallback = EnterNewlyCreatedSecretBase_StartFadeIn;
SetMainCallback2(CB2_LoadMap);
DestroyTask(taskId);
}
}
void EnterNewlyCreatedSecretBase(void)
{
CreateTask(Task_EnterNewlyCreatedSecretBase, 0);
FadeScreen(FADE_TO_BLACK, 0);
}
bool8 CurMapIsSecretBase(void)
{
if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SECRET_BASE_RED_CAVE1)
&& (u8)gSaveBlock1Ptr->location.mapNum <= MAP_NUM(SECRET_BASE_SHRUB4))
return TRUE;
else
return FALSE;
}
void InitSecretBaseAppearance(bool8 hidePC)
{
u16 secretBaseIdx;
u16 x, y;
u8 *decorations;
u8 *decorPos;
if (CurMapIsSecretBase())
{
secretBaseIdx = VarGet(VAR_CURRENT_SECRET_BASE);
decorations = gSaveBlock1Ptr->secretBases[secretBaseIdx].decorations;
decorPos = gSaveBlock1Ptr->secretBases[secretBaseIdx].decorationPositions;
for (x = 0; x < DECOR_MAX_SECRET_BASE; x++)
{
if (decorations[x] > 0 && decorations[x] <= NUM_DECORATIONS && gDecorations[decorations[x]].permission != DECORPERM_SPRITE)
ShowDecorationOnMap((decorPos[x] >> 4) + MAP_OFFSET, (decorPos[x] & 0xF) + MAP_OFFSET, decorations[x]);
}
if (secretBaseIdx != 0)
{
// Another player's secret base. Change PC type to the "Register" PC.
FindMetatileIdMapCoords(&x, &y, METATILE_SecretBase_PC);
MapGridSetMetatileIdAt(x + MAP_OFFSET, y + MAP_OFFSET, METATILE_SecretBase_RegisterPC | METATILE_COLLISION_MASK);
}
else if (hidePC == TRUE && VarGet(VAR_SECRET_BASE_INITIALIZED) == 1)
{
// Change PC to regular ground tile.
FindMetatileIdMapCoords(&x, &y, METATILE_SecretBase_PC);
MapGridSetMetatileIdAt(x + MAP_OFFSET, y + MAP_OFFSET, METATILE_SecretBase_Ground | METATILE_COLLISION_MASK);
}
}
}
void InitSecretBaseDecorationSprites(void)
{
u8 i;
u8 *decorations;
u8 *decorationPositions;
u8 objectEventId;
u8 metatileBehavior;
u8 category;
u8 permission;
u8 numDecorations;
objectEventId = 0;
if (!CurMapIsSecretBase())
{
decorations = gSaveBlock1Ptr->playerRoomDecorations;
decorationPositions = gSaveBlock1Ptr->playerRoomDecorationPositions;
numDecorations = DECOR_MAX_PLAYERS_HOUSE;
}
else
{
u16 secretBaseIdx = VarGet(VAR_CURRENT_SECRET_BASE);
decorations = gSaveBlock1Ptr->secretBases[secretBaseIdx].decorations;
decorationPositions = gSaveBlock1Ptr->secretBases[secretBaseIdx].decorationPositions;
numDecorations = DECOR_MAX_SECRET_BASE;
}
for (i = 0; i < numDecorations; i++)
{
if (decorations[i] == DECOR_NONE)
continue;
permission = gDecorations[decorations[i]].permission;
category = gDecorations[decorations[i]].category;
if (permission == DECORPERM_SPRITE)
{
for (objectEventId = 0; objectEventId < gMapHeader.events->objectEventCount; objectEventId++)
{
if (gMapHeader.events->objectEvents[objectEventId].flagId == FLAG_DECORATION_1 + gSpecialVar_0x8004)
break;
}
if (objectEventId == gMapHeader.events->objectEventCount)
continue;
gSpecialVar_0x8006 = decorationPositions[i] >> 4;
gSpecialVar_0x8007 = decorationPositions[i] & 0xF;
metatileBehavior = MapGridGetMetatileBehaviorAt(gSpecialVar_0x8006 + MAP_OFFSET, gSpecialVar_0x8007 + MAP_OFFSET);
if (MetatileBehavior_HoldsSmallDecoration(metatileBehavior) == TRUE
|| MetatileBehavior_HoldsLargeDecoration(metatileBehavior) == TRUE)
{
gSpecialVar_Result = VAR_OBJ_GFX_ID_0 + (gMapHeader.events->objectEvents[objectEventId].graphicsId - OBJ_EVENT_GFX_VAR_0);
VarSet(gSpecialVar_Result, gDecorations[decorations[i]].tiles[0]);
gSpecialVar_Result = gMapHeader.events->objectEvents[objectEventId].localId;
FlagClear(FLAG_DECORATION_1 + gSpecialVar_0x8004);
TrySpawnObjectEvent(gSpecialVar_Result, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
TryMoveObjectEventToMapCoords(gSpecialVar_Result, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gSpecialVar_0x8006, gSpecialVar_0x8007);
TryOverrideObjectEventTemplateCoords(gSpecialVar_Result, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
if (CurMapIsSecretBase() == TRUE && VarGet(VAR_CURRENT_SECRET_BASE) != 0)
{
if (category == DECORCAT_DOLL)
{
OverrideSecretBaseDecorationSpriteScript(
gSpecialVar_Result,
gSaveBlock1Ptr->location.mapNum,
gSaveBlock1Ptr->location.mapGroup,
DECORCAT_DOLL);
}
else if (category == DECORCAT_CUSHION)
{
OverrideSecretBaseDecorationSpriteScript(
gSpecialVar_Result,
gSaveBlock1Ptr->location.mapNum,
gSaveBlock1Ptr->location.mapGroup,
DECORCAT_CUSHION);
}
}
gSpecialVar_0x8004++;
}
}
}
}
void HideSecretBaseDecorationSprites(void)
{
u8 objectEventId;
u16 flag;
for (objectEventId = 0; objectEventId < gMapHeader.events->objectEventCount; objectEventId++)
{
flag = gMapHeader.events->objectEvents[objectEventId].flagId;
if (flag >= FLAG_DECORATION_1 && flag <= FLAG_DECORATION_14)
{
RemoveObjectEventByLocalIdAndMap(
gMapHeader.events->objectEvents[objectEventId].localId,
gSaveBlock1Ptr->location.mapNum,
gSaveBlock1Ptr->location.mapGroup);
FlagSet(flag);
}
}
}
void SetSecretBaseOwnerGfxId(void)
{
VarSet(VAR_OBJ_GFX_ID_F, sSecretBaseOwnerGfxIds[GetSecretBaseOwnerType(VarGet(VAR_CURRENT_SECRET_BASE))]);
}
void SetCurSecretBaseIdFromPosition(const struct MapPosition *position, const struct MapEvents *events)
{
s16 i;
for (i = 0; i < events->bgEventCount; i++)
{
if (events->bgEvents[i].kind == BG_EVENT_SECRET_BASE
&& position->x == events->bgEvents[i].x + MAP_OFFSET
&& position->y == events->bgEvents[i].y + MAP_OFFSET)
{
sCurSecretBaseId = events->bgEvents[i].bgUnion.secretBaseId;
break;
}
}
}
void WarpIntoSecretBase(const struct MapPosition *position, const struct MapEvents *events)
{
SetCurSecretBaseIdFromPosition(position, events);
TrySetCurSecretBaseIndex();
ScriptContext1_SetupScript(SecretBase_EventScript_Enter);
}
bool8 TrySetCurSecretBase(void)
{
SetCurSecretBaseId();
TrySetCurSecretBaseIndex();
if (gSpecialVar_Result == TRUE)
return FALSE;
return TRUE;
}
static void Task_WarpOutOfSecretBase(u8 taskId)
{
switch (gTasks[taskId].data[0])
{
case 0:
ScriptContext2_Enable();
gTasks[taskId].data[0] = 1;
break;
case 1:
if (!gPaletteFade.active)
gTasks[taskId].data[0] = 2;
break;
case 2:
SetWarpDestinationToDynamicWarp(WARP_ID_SECRET_BASE);
WarpIntoMap();
gFieldCallback = FieldCB_DefaultWarpExit;
SetMainCallback2(CB2_LoadMap);
ScriptContext2_Disable();
DestroyTask(taskId);
break;
}
}
static void WarpOutOfSecretBase(void)
{
CreateTask(Task_WarpOutOfSecretBase, 0);
FadeScreen(FADE_TO_BLACK, 0);
}
void IsCurSecretBaseOwnedByAnotherPlayer(void)
{
if (gSaveBlock1Ptr->secretBases[0].secretBaseId != sCurSecretBaseId)
gSpecialVar_Result = TRUE;
else
gSpecialVar_Result = FALSE;
}
static u8 *GetSecretBaseName(u8 *dest, u8 secretBaseIdx)
{
*StringCopyN(dest, gSaveBlock1Ptr->secretBases[secretBaseIdx].trainerName, GetNameLength(gSaveBlock1Ptr->secretBases[secretBaseIdx].trainerName)) = EOS;
ConvertInternationalString(dest, gSaveBlock1Ptr->secretBases[secretBaseIdx].language);
return StringAppend(dest, gText_ApostropheSBase);
}
u8 *GetSecretBaseMapName(u8 *dest)
{
return GetSecretBaseName(dest, VarGet(VAR_CURRENT_SECRET_BASE));
}
void CopyCurSecretBaseOwnerName_StrVar1(void)
{
u8 secretBaseIdx;
const u8 *name;
secretBaseIdx = VarGet(VAR_CURRENT_SECRET_BASE);
name = gSaveBlock1Ptr->secretBases[secretBaseIdx].trainerName;
*StringCopyN(gStringVar1, name, GetNameLength(name)) = EOS;
ConvertInternationalString(gStringVar1, gSaveBlock1Ptr->secretBases[secretBaseIdx].language);
}
static bool8 IsSecretBaseRegistered(u8 secretBaseIdx)
{
if (gSaveBlock1Ptr->secretBases[secretBaseIdx].registryStatus)
return TRUE;
return FALSE;
}
static u8 GetAverageEVs(struct Pokemon *pokemon)
{
u16 evTotal;
evTotal = GetMonData(pokemon, MON_DATA_HP_EV);
evTotal += GetMonData(pokemon, MON_DATA_ATK_EV);
evTotal += GetMonData(pokemon, MON_DATA_DEF_EV);
evTotal += GetMonData(pokemon, MON_DATA_SPEED_EV);
evTotal += GetMonData(pokemon, MON_DATA_SPATK_EV);
evTotal += GetMonData(pokemon, MON_DATA_SPDEF_EV);
return evTotal / 6;
}
void SetPlayerSecretBaseParty(void)
{
u16 i;
u16 moveIdx;
u16 partyId;
struct SecretBaseParty *party;
partyId = 0;
party = &gSaveBlock1Ptr->secretBases[0].party;
if (gSaveBlock1Ptr->secretBases[0].secretBaseId)
{
for (i = 0; i < PARTY_SIZE; i++)
{
for (moveIdx = 0; moveIdx < MAX_MON_MOVES; moveIdx++)
party->moves[i * MAX_MON_MOVES + moveIdx] = MOVE_NONE;
party->species[i] = SPECIES_NONE;
party->heldItems[i] = ITEM_NONE;
party->levels[i] = 0;
party->personality[i] = 0;
party->EVs[i] = 0;
if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
&& !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
{
for (moveIdx = 0; moveIdx < MAX_MON_MOVES; moveIdx++)
party->moves[partyId * MAX_MON_MOVES + moveIdx] = GetMonData(&gPlayerParty[i], MON_DATA_MOVE1 + moveIdx);
party->species[partyId] = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES);
party->heldItems[partyId] = GetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM);
party->levels[partyId] = GetMonData(&gPlayerParty[i], MON_DATA_LEVEL);
party->personality[partyId] = GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY);
party->EVs[partyId] = GetAverageEVs(&gPlayerParty[i]);
partyId++;
}
}
}
}
void ClearAndLeaveSecretBase(void)
{
u16 temp = gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived;
ClearSecretBase(&gSaveBlock1Ptr->secretBases[0]);
gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived = temp;
WarpOutOfSecretBase();
}
void MoveOutOfSecretBase(void)
{
IncrementGameStat(GAME_STAT_MOVED_SECRET_BASE);
ClearAndLeaveSecretBase();
}
static void ClosePlayerSecretBaseEntrance(void)
{
u16 i;
u16 j;
s16 metatileId;
const struct MapEvents *events = gMapHeader.events;
for (i = 0; i < events->bgEventCount; i++)
{
if (events->bgEvents[i].kind == BG_EVENT_SECRET_BASE
&& gSaveBlock1Ptr->secretBases[0].secretBaseId == events->bgEvents[i].bgUnion.secretBaseId)
{
metatileId = MapGridGetMetatileIdAt(events->bgEvents[i].x + MAP_OFFSET, events->bgEvents[i].y + MAP_OFFSET);
for (j = 0; j < ARRAY_COUNT(sSecretBaseEntranceMetatiles); j++)
{
if (sSecretBaseEntranceMetatiles[j].openMetatileId == metatileId)
{
MapGridSetMetatileIdAt(events->bgEvents[i].x + MAP_OFFSET,
events->bgEvents[i].y + MAP_OFFSET,
sSecretBaseEntranceMetatiles[j].closedMetatileId | METATILE_COLLISION_MASK);
break;
}
}
DrawWholeMapView();
break;
}
}
}
// When the player moves to a new secret base by interacting with a new secret base
// entrance in the overworld.
void MoveOutOfSecretBaseFromOutside(void)
{
u16 temp;
ClosePlayerSecretBaseEntrance();
IncrementGameStat(GAME_STAT_MOVED_SECRET_BASE);
temp = gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived;
ClearSecretBase(&gSaveBlock1Ptr->secretBases[0]);
gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived = temp;
}
static u8 GetNumRegisteredSecretBases(void)
{
s16 i;
u8 count = 0;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (IsSecretBaseRegistered(i) == TRUE)
count++;
}
return count;
}
void GetCurSecretBaseRegistrationValidity(void)
{
if (IsSecretBaseRegistered(VarGet(VAR_CURRENT_SECRET_BASE)) == TRUE)
gSpecialVar_Result = 1;
else if (GetNumRegisteredSecretBases() >= 10)
gSpecialVar_Result = 2;
else
gSpecialVar_Result = 0;
}
void ToggleCurSecretBaseRegistry(void)
{
gSaveBlock1Ptr->secretBases[VarGet(VAR_CURRENT_SECRET_BASE)].registryStatus ^= 1;
FlagSet(FLAG_SECRET_BASE_REGISTRY_ENABLED);
}
void ShowSecretBaseDecorationMenu(void)
{
CreateTask(DoSecretBaseDecorationMenu, 0);
}
void ShowSecretBaseRegistryMenu(void)
{
CreateTask(Task_ShowSecretBaseRegistryMenu, 0);
}
#define tNumBases data[0]
#define tSelectedRow data[1]
#define tScrollOffset data[2]
#define tMaxShownItems data[3]
#define tSelectedBaseId data[4]
#define tListTaskId data[5]
#define tMainWindowId data[6]
#define tActionWindowId data[7]
#define tArrowTaskId data[8]
static void Task_ShowSecretBaseRegistryMenu(u8 taskId)
{
s16 *data = gTasks[taskId].data;
ScriptContext2_Enable();
tNumBases = GetNumRegisteredSecretBases();
if (tNumBases != 0)
{
tSelectedRow = 0;
tScrollOffset = 0;
ClearDialogWindowAndFrame(0, 0);
sRegistryMenu = calloc(1, sizeof(*sRegistryMenu));
tMainWindowId = AddWindow(&sRegistryWindowTemplates[0]);
BuildRegistryMenuItems(taskId);
FinalizeRegistryMenu(taskId);
gTasks[taskId].func = HandleRegistryMenuInput;
}
else
{
DisplayItemMessageOnField(taskId, gText_NoRegistry, GoToSecretBasePCRegisterMenu);
}
}
static void BuildRegistryMenuItems(u8 taskId)
{
s16 *data;
u8 i;
u8 count;
data = gTasks[taskId].data;
count = 0;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (IsSecretBaseRegistered(i))
{
GetSecretBaseName(sRegistryMenu->names[count], i);
sRegistryMenu->items[count].name = sRegistryMenu->names[count];
sRegistryMenu->items[count].id = i;
count++;
}
}
sRegistryMenu->items[count].name = gText_Cancel;
sRegistryMenu->items[count].id = -2;
tNumBases = count + 1;
if (tNumBases < 8)
tMaxShownItems = tNumBases;
else
tMaxShownItems = 8;
gMultiuseListMenuTemplate = sRegistryListMenuTemplate;
gMultiuseListMenuTemplate.windowId = tMainWindowId;
gMultiuseListMenuTemplate.totalItems = tNumBases;
gMultiuseListMenuTemplate.items = sRegistryMenu->items;
gMultiuseListMenuTemplate.maxShowed = tMaxShownItems;
}
static void RegistryMenu_OnCursorMove(s32 unused, bool8 flag, struct ListMenu *menu)
{
if (flag != TRUE)
PlaySE(SE_SELECT);
}
static void FinalizeRegistryMenu(u8 taskId)
{
s16 *data = gTasks[taskId].data;
SetStandardWindowBorderStyle(tMainWindowId, 0);
tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, tScrollOffset, tSelectedRow);
AddRegistryMenuScrollArrows(taskId);
ScheduleBgCopyTilemapToVram(0);
}
static void AddRegistryMenuScrollArrows(u8 taskId)
{
s16 *data = gTasks[taskId].data;
tArrowTaskId = AddScrollIndicatorArrowPairParameterized(SCROLL_ARROW_UP, 188, 12, 148, tNumBases - tMaxShownItems, 0x13f8, 0x13f8, &tScrollOffset);
}
static void HandleRegistryMenuInput(u8 taskId)
{
s16 *data = gTasks[taskId].data;
s32 input = ListMenu_ProcessInput(tListTaskId);
ListMenuGetScrollAndRow(tListTaskId, &tScrollOffset, &tSelectedRow);
switch (input)
{
case LIST_NOTHING_CHOSEN:
break;
case LIST_CANCEL:
PlaySE(SE_SELECT);
DestroyListMenuTask(tListTaskId, NULL, NULL);
RemoveScrollIndicatorArrowPair(tArrowTaskId);
ClearStdWindowAndFrame(tMainWindowId, 0);
ClearWindowTilemap(tMainWindowId);
RemoveWindow(tMainWindowId);
ScheduleBgCopyTilemapToVram(0);
free(sRegistryMenu);
GoToSecretBasePCRegisterMenu(taskId);
break;
default:
PlaySE(SE_SELECT);
tSelectedBaseId = input;
ShowRegistryMenuActions(taskId);
break;
}
}
static void ShowRegistryMenuActions(u8 taskId)
{
struct WindowTemplate template;
s16 *data = gTasks[taskId].data;
RemoveScrollIndicatorArrowPair(tArrowTaskId);
template = sRegistryWindowTemplates[1];
template.width = GetMaxWidthInMenuTable(sRegistryMenuActions, 2);
tActionWindowId = AddWindow(&template);
SetStandardWindowBorderStyle(tActionWindowId, 0);
PrintMenuTable(tActionWindowId, ARRAY_COUNT(sRegistryMenuActions), sRegistryMenuActions);
InitMenuInUpperLeftCornerNormal(tActionWindowId, 2, 0);
ScheduleBgCopyTilemapToVram(0);
gTasks[taskId].func = HandleRegistryMenuActionsInput;
}
static void HandleRegistryMenuActionsInput(u8 taskId)
{
s8 input = Menu_ProcessInputNoWrap();
switch (input)
{
case MENU_B_PRESSED:
PlaySE(SE_SELECT);
ReturnToMainRegistryMenu(taskId);
break;
case MENU_NOTHING_CHOSEN:
break;
default:
PlaySE(SE_SELECT);
sRegistryMenuActions[input].func.void_u8(taskId);
break;
}
}
static void ShowRegistryMenuDeleteConfirmation(u8 taskId)
{
s16 *data = gTasks[taskId].data;
ClearStdWindowAndFrame(tMainWindowId, FALSE);
ClearStdWindowAndFrame(tActionWindowId, FALSE);
ClearWindowTilemap(tMainWindowId);
ClearWindowTilemap(tActionWindowId);
RemoveWindow(tActionWindowId);
ScheduleBgCopyTilemapToVram(0);
GetSecretBaseName(gStringVar1, tSelectedBaseId);
StringExpandPlaceholders(gStringVar4, gText_OkayToDeleteFromRegistry);
DisplayItemMessageOnField(taskId, gStringVar4, ShowRegistryMenuDeleteYesNo);
}
static void ShowRegistryMenuDeleteYesNo(u8 taskId)
{
DisplayYesNoMenuDefaultYes();
DoYesNoFuncWithChoice(taskId, &sDeleteRegistryYesNoFuncs);
}
void DeleteRegistry_Yes_Callback(u8 taskId)
{
s16 *data = gTasks[taskId].data;
ClearDialogWindowAndFrame(0, 0);
DestroyListMenuTask(tListTaskId, &tScrollOffset, &tSelectedRow);
gSaveBlock1Ptr->secretBases[tSelectedBaseId].registryStatus = UNREGISTERED;
BuildRegistryMenuItems(taskId);
SetCursorWithinListBounds(&tScrollOffset, &tSelectedRow, tMaxShownItems, tNumBases);
FinalizeRegistryMenu(taskId);
gTasks[taskId].func = HandleRegistryMenuInput;
}
static void DeleteRegistry_Yes(u8 taskId)
{
DisplayItemMessageOnField(taskId, gText_RegisteredDataDeleted, DeleteRegistry_Yes_Callback);
}
static void DeleteRegistry_No(u8 taskId)
{
s16 *data = gTasks[taskId].data;
ClearDialogWindowAndFrame(0, 0);
DestroyListMenuTask(tListTaskId, &tScrollOffset, &tSelectedRow);
FinalizeRegistryMenu(taskId);
gTasks[taskId].func = HandleRegistryMenuInput;
}
static void ReturnToMainRegistryMenu(u8 taskId)
{
s16 *data = gTasks[taskId].data;
AddRegistryMenuScrollArrows(taskId);
ClearStdWindowAndFrame(tActionWindowId, 0);
ClearWindowTilemap(tActionWindowId);
RemoveWindow(tActionWindowId);
ScheduleBgCopyTilemapToVram(0);
gTasks[taskId].func = HandleRegistryMenuInput;
}
static void GoToSecretBasePCRegisterMenu(u8 taskId)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) == 0)
ScriptContext1_SetupScript(SecretBase_EventScript_PCCancel);
else
ScriptContext1_SetupScript(SecretBase_EventScript_ShowRegisterMenu);
DestroyTask(taskId);
}
#undef tNumBases
#undef tSelectedRow
#undef tScrollOffset
#undef tMaxShownItems
#undef tSelectedBaseId
#undef tListTaskId
#undef tMainWindowId
#undef tActionWindowId
#undef tArrowTaskId
static u8 GetSecretBaseOwnerType(u8 secretBaseIdx)
{
return (gSaveBlock1Ptr->secretBases[secretBaseIdx].trainerId[0] % 5)
+ (gSaveBlock1Ptr->secretBases[secretBaseIdx].gender * 5);
}
const u8 *GetSecretBaseTrainerLoseText(void)
{
u8 ownerType = GetSecretBaseOwnerType(VarGet(VAR_CURRENT_SECRET_BASE));
if (ownerType == 0)
return SecretBase_Text_Trainer0Defeated;
else if (ownerType == 1)
return SecretBase_Text_Trainer1Defeated;
else if (ownerType == 2)
return SecretBase_Text_Trainer2Defeated;
else if (ownerType == 3)
return SecretBase_Text_Trainer3Defeated;
else if (ownerType == 4)
return SecretBase_Text_Trainer4Defeated;
else if (ownerType == 5)
return SecretBase_Text_Trainer5Defeated;
else if (ownerType == 6)
return SecretBase_Text_Trainer6Defeated;
else if (ownerType == 7)
return SecretBase_Text_Trainer7Defeated;
else if (ownerType == 8)
return SecretBase_Text_Trainer8Defeated;
else
return SecretBase_Text_Trainer9Defeated;
}
void PrepSecretBaseBattleFlags(void)
{
TryGainNewFanFromCounter(FANCOUNTER_BATTLED_AT_BASE);
gTrainerBattleOpponent_A = TRAINER_SECRET_BASE;
gBattleTypeFlags = BATTLE_TYPE_TRAINER | BATTLE_TYPE_SECRET_BASE;
}
void SetBattledOwnerFromResult(void)
{
gSaveBlock1Ptr->secretBases[VarGet(VAR_CURRENT_SECRET_BASE)].battledOwnerToday = gSpecialVar_Result;
}
void GetSecretBaseOwnerAndState(void)
{
u16 secretBaseIdx;
u8 i;
secretBaseIdx = VarGet(VAR_CURRENT_SECRET_BASE);
if (!FlagGet(FLAG_DAILY_SECRET_BASE))
{
for (i = 0; i < SECRET_BASES_COUNT; i++)
gSaveBlock1Ptr->secretBases[i].battledOwnerToday = FALSE;
FlagSet(FLAG_DAILY_SECRET_BASE);
}
gSpecialVar_0x8004 = GetSecretBaseOwnerType(secretBaseIdx);
gSpecialVar_Result = gSaveBlock1Ptr->secretBases[secretBaseIdx].battledOwnerToday;
}
#define tStepCb data[0] // See Task_RunPerStepCallback
#define tState data[1]
#define tPlayerX data[2]
#define tPlayerY data[3]
#define tFldEff data[4]
void SecretBasePerStepCallback(u8 taskId)
{
s16 x;
s16 y;
u8 behavior;
u16 tileId;
s16 *data;
data = gTasks[taskId].data;
switch (tState)
{
case 0:
if (VarGet(VAR_CURRENT_SECRET_BASE))
sInFriendSecretBase = TRUE;
else
sInFriendSecretBase = FALSE;
PlayerGetDestCoords(&tPlayerX, &tPlayerY);
tState = 1;
break;
case 1:
// End if player hasn't moved
PlayerGetDestCoords(&x, &y);
if (x == tPlayerX && y == tPlayerY)
return;
tPlayerX = x;
tPlayerY = y;
VarSet(VAR_SECRET_BASE_STEP_COUNTER, VarGet(VAR_SECRET_BASE_STEP_COUNTER) + 1);
behavior = MapGridGetMetatileBehaviorAt(x, y);
tileId = MapGridGetMetatileIdAt(x, y);
if (tileId == METATILE_SecretBase_SolidBoard_Top || tileId == METATILE_SecretBase_SolidBoard_Bottom)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_SOLID_BOARD);
}
else if (tileId == METATILE_SecretBase_SmallChair
|| tileId == METATILE_SecretBase_PokemonChair
|| tileId == METATILE_SecretBase_HeavyChair
|| tileId == METATILE_SecretBase_PrettyChair
|| tileId == METATILE_SecretBase_ComfortChair
|| tileId == METATILE_SecretBase_RaggedChair
|| tileId == METATILE_SecretBase_BrickChair
|| tileId == METATILE_SecretBase_CampChair
|| tileId == METATILE_SecretBase_HardChair)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_CHAIR);
}
else if (tileId == METATILE_SecretBase_RedTent_DoorTop
|| tileId == METATILE_SecretBase_RedTent_Door
|| tileId == METATILE_SecretBase_BlueTent_DoorTop
|| tileId == METATILE_SecretBase_BlueTent_Door)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_TENT);
}
else if ((behavior == MB_IMPASSABLE_NORTHEAST && tileId == METATILE_SecretBase_Stand_CornerRight)
|| (behavior == MB_IMPASSABLE_NORTHWEST && MapGridGetMetatileIdAt(x, y) == METATILE_SecretBase_Stand_CornerLeft))
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_STAND);
}
else if (behavior == MB_IMPASSABLE_WEST_AND_EAST && tileId == METATILE_SecretBase_Slide_StairLanding)
{
if (sInFriendSecretBase == TRUE)
{
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) ^ SECRET_BASE_USED_SLIDE);
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_DECLINED_SLIDE);
}
}
else if (behavior == MB_SLIDE_SOUTH && tileId == METATILE_SecretBase_Slide_SlideTop)
{
if (sInFriendSecretBase == TRUE)
{
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_SLIDE);
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) ^ SECRET_BASE_DECLINED_SLIDE);
}
}
else if (MetatileBehavior_IsSecretBaseGlitterMat(behavior) == TRUE)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_GLITTER_MAT);
}
else if (MetatileBehavior_IsSecretBaseBalloon(behavior) == TRUE)
{
PopSecretBaseBalloon(MapGridGetMetatileIdAt(x, y), x, y);
if (sInFriendSecretBase == TRUE)
{
switch ((int)MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_RedBalloon:
case METATILE_SecretBase_BlueBalloon:
case METATILE_SecretBase_YellowBalloon:
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_BALLOON);
break;
case METATILE_SecretBase_MudBall:
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_MUD_BALL);
break;
}
}
}
else if (MetatileBehavior_IsSecretBaseBreakableDoor(behavior) == TRUE)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_BREAKABLE_DOOR);
ShatterSecretBaseBreakableDoor(x, y);
}
else if (MetatileBehavior_IsSecretBaseSoundMat(behavior) == TRUE){
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_NOTE_MAT);
}
else if (MetatileBehavior_IsSecretBaseJumpMat(behavior) == TRUE)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_JUMP_MAT);
}
else if (MetatileBehavior_IsSecretBaseSpinMat(behavior) == TRUE)
{
if (sInFriendSecretBase == TRUE)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_SPIN_MAT);
}
break;
case 2:
// This state is never reached, and tFldEff is never set
if (!FieldEffectActiveListContains(tFldEff))
tState = 1;
break;
}
}
#undef tStepCb
#undef tState
#undef tPlayerX
#undef tPlayerY
#undef tFldEff
static void SaveSecretBase(u8 secretBaseIdx, struct SecretBase *secretBase, u32 version, u32 language)
{
int stringLength;
u8 *name;
gSaveBlock1Ptr->secretBases[secretBaseIdx] = *secretBase;
gSaveBlock1Ptr->secretBases[secretBaseIdx].registryStatus = NEW;
if (version == VERSION_SAPPHIRE || version == VERSION_RUBY)
gSaveBlock1Ptr->secretBases[secretBaseIdx].language = GAME_LANGUAGE;
if (version == VERSION_EMERALD && language == LANGUAGE_JAPANESE)
{
name = gSaveBlock1Ptr->secretBases[secretBaseIdx].trainerName;
for (stringLength = 0; stringLength < PLAYER_NAME_LENGTH; stringLength++)
{
if (name[stringLength] == EOS)
break;
}
if (stringLength > 5)
gSaveBlock1Ptr->secretBases[secretBaseIdx].language = GAME_LANGUAGE;
}
}
static bool8 SecretBasesHaveSameTrainerId(struct SecretBase *secretBase1, struct SecretBase *secretBase2)
{
u8 i;
for (i = 0; i < TRAINER_ID_LENGTH; i++)
{
if (secretBase1->trainerId[i] != secretBase2->trainerId[i])
return FALSE;
}
return TRUE;
}
static bool8 SecretBasesHaveSameTrainerName(struct SecretBase *sbr1, struct SecretBase *sbr2)
{
u8 i;
for (i = 0; i < PLAYER_NAME_LENGTH && (sbr1->trainerName[i] != EOS || sbr2->trainerName[i] != EOS); i++)
{
if (sbr1->trainerName[i] != sbr2->trainerName[i])
return FALSE;
}
return TRUE;
}
static bool8 SecretBasesBelongToSamePlayer(struct SecretBase *secretBase1, struct SecretBase *secretBase2)
{
if (secretBase1->gender == secretBase2->gender
&& SecretBasesHaveSameTrainerId(secretBase1, secretBase2)
&& SecretBasesHaveSameTrainerName(secretBase1, secretBase2))
{
return TRUE;
}
return FALSE;
}
static s16 GetSecretBaseIndexFromId(u8 secretBaseId)
{
s16 i;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (gSaveBlock1Ptr->secretBases[i].secretBaseId == secretBaseId)
return i;
}
return -1;
}
static u8 FindAvailableSecretBaseIndex(void)
{
s16 i;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (gSaveBlock1Ptr->secretBases[i].secretBaseId == 0)
return i;
}
return 0;
}
static u8 FindUnregisteredSecretBaseIndex(void)
{
s16 i;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (gSaveBlock1Ptr->secretBases[i].registryStatus == UNREGISTERED && gSaveBlock1Ptr->secretBases[i].toRegister == FALSE)
return i;
}
return 0;
}
static u8 TrySaveFriendsSecretBase(struct SecretBase *secretBase, u32 version, u32 language)
{
s16 index;
// Secret base has no location
if (!secretBase->secretBaseId)
return 0;
index = GetSecretBaseIndexFromId(secretBase->secretBaseId);
if (index != 0)
{
// An existing secret base is using this location
if (index != -1)
{
if (gSaveBlock1Ptr->secretBases[index].toRegister == TRUE)
return 0;
if (gSaveBlock1Ptr->secretBases[index].registryStatus != NEW || secretBase->toRegister == TRUE)
{
// Overwrite unregistered base at this location
SaveSecretBase(index, secretBase, version, language);
return index;
}
}
// No secret base is using this location, find a spot to save it
else
{
index = FindAvailableSecretBaseIndex();
if (index != 0)
{
// Save in empty space
SaveSecretBase(index, secretBase, version, language);
return index;
}
index = FindUnregisteredSecretBaseIndex();
if (index != 0)
{
// Overwrite unregistered base
SaveSecretBase(index, secretBase, version, language);
return index;
}
}
}
// Unable to save. Either...
// - This was the player's base
// - A registered base exists at this location
// - The secret base limit has been filled with registered bases
return 0;
}
// Moves the registered secret bases to the beginning of the array, so that
// they won't be forgotten during record mixing.
static void SortSecretBasesByRegistryStatus(void)
{
u8 i;
u8 j;
struct SecretBase *secretBases;
secretBases = gSaveBlock1Ptr->secretBases;
for (i = 1; i < SECRET_BASES_COUNT - 1; i++)
{
for (j = i + 1; j < SECRET_BASES_COUNT; j++)
{
if ((secretBases[i].registryStatus == UNREGISTERED && secretBases[j].registryStatus == REGISTERED)
|| (secretBases[i].registryStatus == NEW && secretBases[j].registryStatus != NEW))
{
struct SecretBase temp;
SWAP(secretBases[i], secretBases[j], temp)
}
}
}
}
// Used to save a record mixing friends' bases other than their own
// registryStatus is so registered bases can be attempted first
static void TrySaveFriendsSecretBases(struct SecretBaseRecordMixer *mixer, u8 registryStatus)
{
u16 i;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (mixer->secretBases[i].registryStatus == registryStatus)
TrySaveFriendsSecretBase(&mixer->secretBases[i], mixer->version, mixer->language);
}
}
static bool8 SecretBaseBelongsToPlayer(struct SecretBase *secretBase)
{
u8 i;
if (secretBase->secretBaseId == 0)
return FALSE;
if (secretBase->secretBaseId && secretBase->gender != gSaveBlock2Ptr->playerGender)
return FALSE;
// Check if the player's trainer Id matches the secret base's id.
for (i = 0; i < TRAINER_ID_LENGTH; i++)
{
if (secretBase->trainerId[i] != gSaveBlock2Ptr->playerTrainerId[i])
return FALSE;
}
for (i = 0; i < PLAYER_NAME_LENGTH && (secretBase->trainerName[i] != EOS || gSaveBlock2Ptr->playerName[i] != EOS); i++)
{
if (secretBase->trainerName[i] != gSaveBlock2Ptr->playerName[i])
return FALSE;
}
return TRUE;
}
#define DELETED_BASE_A (1 << 0)
#define DELETED_BASE_B (1 << 1)
#define DELETED_BASE_C (1 << 2)
static void DeleteFirstOldBaseFromPlayerInRecordMixingFriendsRecords(struct SecretBase *basesA, struct SecretBase *basesB, struct SecretBase *basesC)
{
u8 i;
u8 sbFlags = 0;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (!(sbFlags & DELETED_BASE_A))
{
if (SecretBaseBelongsToPlayer(&basesA[i]) == TRUE)
{
ClearSecretBase(&basesA[i]);
sbFlags |= DELETED_BASE_A;
}
}
if (!(sbFlags & DELETED_BASE_B))
{
if (SecretBaseBelongsToPlayer(&basesB[i]) == TRUE)
{
ClearSecretBase(&basesB[i]);
sbFlags |= DELETED_BASE_B;
}
}
if (!(sbFlags & DELETED_BASE_C))
{
if (SecretBaseBelongsToPlayer(&basesC[i]) == TRUE)
{
ClearSecretBase(&basesC[i]);
sbFlags |= DELETED_BASE_C;
}
}
if (sbFlags == (DELETED_BASE_A | DELETED_BASE_B | DELETED_BASE_C))
{
break;
}
}
}
#undef DELETED_BASE_A
#undef DELETED_BASE_B
#undef DELETED_BASE_C
// returns TRUE if secretBase was deleted, FALSE otherwise
static bool8 ClearDuplicateOwnedSecretBase(struct SecretBase *secretBase, struct SecretBase *secretBases, u8 idx)
{
u8 i;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (secretBases[i].secretBaseId != 0)
{
if (SecretBasesBelongToSamePlayer(secretBase, &secretBases[i]) == TRUE)
{
if (idx == 0)
{
ClearSecretBase(&secretBases[i]);
return FALSE;
}
if (secretBase->numSecretBasesReceived > secretBases[i].numSecretBasesReceived)
{
ClearSecretBase(&secretBases[i]);
return FALSE;
}
secretBases[i].toRegister = secretBase->toRegister;
ClearSecretBase(secretBase);
return TRUE;
}
}
}
return FALSE;
}
static void ClearDuplicateOwnedSecretBases(struct SecretBase *playersBases, struct SecretBase *friendsBasesA, struct SecretBase *friendsBasesB, struct SecretBase *friendsBasesC)
{
u8 i;
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
if (playersBases[i].secretBaseId)
{
if (playersBases[i].registryStatus == REGISTERED)
{
// Mark registered bases, so if they're deleted as a duplicate they
// will be re-registered later
playersBases[i].toRegister = TRUE;
}
if (!ClearDuplicateOwnedSecretBase(&playersBases[i], friendsBasesA, i))
{
if (!ClearDuplicateOwnedSecretBase(&playersBases[i], friendsBasesB, i))
{
ClearDuplicateOwnedSecretBase(&playersBases[i], friendsBasesC, i);
}
}
}
}
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (friendsBasesA[i].secretBaseId)
{
friendsBasesA[i].battledOwnerToday = 0;
if (!ClearDuplicateOwnedSecretBase(&friendsBasesA[i], friendsBasesB, i))
{
ClearDuplicateOwnedSecretBase(&friendsBasesA[i], friendsBasesC, i);
}
}
}
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (friendsBasesB[i].secretBaseId)
{
friendsBasesB[i].battledOwnerToday = 0;
ClearDuplicateOwnedSecretBase(&friendsBasesB[i], friendsBasesC, i);
}
if (friendsBasesC[i].secretBaseId)
{
friendsBasesC[i].battledOwnerToday = 0;
}
}
}
static void TrySaveRegisteredDuplicate(struct SecretBase *base, u32 version, u32 language)
{
if (base->toRegister == TRUE)
{
TrySaveFriendsSecretBase(base, version, language);
ClearSecretBase(base);
}
}
static void TrySaveRegisteredDuplicates(struct SecretBaseRecordMixer *mixers)
{
u16 i;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
TrySaveRegisteredDuplicate(&mixers[0].secretBases[i], mixers[0].version, mixers[0].language);
TrySaveRegisteredDuplicate(&mixers[1].secretBases[i], mixers[1].version, mixers[1].language);
TrySaveRegisteredDuplicate(&mixers[2].secretBases[i], mixers[2].version, mixers[2].language);
}
}
static void SaveRecordMixBases(struct SecretBaseRecordMixer *mixers)
{
DeleteFirstOldBaseFromPlayerInRecordMixingFriendsRecords(mixers[0].secretBases, mixers[1].secretBases, mixers[2].secretBases);
ClearDuplicateOwnedSecretBases(gSaveBlock1Ptr->secretBases, mixers[0].secretBases, mixers[1].secretBases, mixers[2].secretBases);
// First, save any registered secret bases that were deleted as duplicates
TrySaveRegisteredDuplicates(mixers);
// Then try to save the record mixing friends' own bases
TrySaveFriendsSecretBase(mixers[0].secretBases, mixers[0].version, mixers[0].language);
TrySaveFriendsSecretBase(mixers[1].secretBases, mixers[1].version, mixers[1].language);
TrySaveFriendsSecretBase(mixers[2].secretBases, mixers[2].version, mixers[2].language);
// Then try to save as many of their registered bases as possible
TrySaveFriendsSecretBases(&mixers[0], REGISTERED);
TrySaveFriendsSecretBases(&mixers[1], REGISTERED);
TrySaveFriendsSecretBases(&mixers[2], REGISTERED);
// Lastly save as many of their unregistered bases as possible
TrySaveFriendsSecretBases(&mixers[0], UNREGISTERED);
TrySaveFriendsSecretBases(&mixers[1], UNREGISTERED);
TrySaveFriendsSecretBases(&mixers[2], UNREGISTERED);
}
#define INIT_SECRET_BASE_RECORD_MIXER(linkId1, linkId2, linkId3) \
mixers[0].secretBases = secretBases + linkId1 * recordSize; \
mixers[0].version = gLinkPlayers[linkId1].version & 0xFF; \
mixers[0].language = gLinkPlayers[linkId1].language; \
mixers[1].secretBases = secretBases + linkId2 * recordSize; \
mixers[1].version = gLinkPlayers[linkId2].version & 0xFF; \
mixers[1].language = gLinkPlayers[linkId2].language; \
mixers[2].secretBases = secretBases + linkId3 * recordSize; \
mixers[2].version = gLinkPlayers[linkId3].version & 0xFF; \
mixers[2].language = gLinkPlayers[linkId3].language;
void ReceiveSecretBasesData(void *secretBases, size_t recordSize, u8 linkIdx)
{
struct SecretBaseRecordMixer mixers[3];
u16 i;
if (FlagGet(FLAG_RECEIVED_SECRET_POWER))
{
switch (GetLinkPlayerCount())
{
case 2:
memset(secretBases + 2 * recordSize, 0, recordSize);
memset(secretBases + 3 * recordSize, 0, recordSize);
break;
case 3:
memset(secretBases + 3 * recordSize, 0, recordSize);
break;
}
switch (linkIdx)
{
case 0:
INIT_SECRET_BASE_RECORD_MIXER(1, 2, 3)
break;
case 1:
INIT_SECRET_BASE_RECORD_MIXER(2, 3, 0)
break;
case 2:
INIT_SECRET_BASE_RECORD_MIXER(3, 0, 1)
break;
case 3:
INIT_SECRET_BASE_RECORD_MIXER(0, 1, 2)
break;
}
SaveRecordMixBases(mixers);
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
// In the process of deleting duplicate bases, if a base the player has registered is deleted it is
// flagged with the temporary toRegister flag, so it can be re-registered after it has been newly saved
if (gSaveBlock1Ptr->secretBases[i].toRegister == TRUE)
{
gSaveBlock1Ptr->secretBases[i].registryStatus = REGISTERED;
gSaveBlock1Ptr->secretBases[i].toRegister = FALSE;
}
}
SortSecretBasesByRegistryStatus();
for (i = 1; i < SECRET_BASES_COUNT; i++)
{
// Unmark "new" bases, they've been saved now and are no longer important
if (gSaveBlock1Ptr->secretBases[i].registryStatus == NEW)
gSaveBlock1Ptr->secretBases[i].registryStatus = UNREGISTERED;
}
if (gSaveBlock1Ptr->secretBases[0].secretBaseId != 0
&& gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived != 0xFFFF)
{
gSaveBlock1Ptr->secretBases[0].numSecretBasesReceived++;
}
}
}
void ClearJapaneseSecretBases(struct SecretBase *bases)
{
u32 i;
for (i = 0; i < SECRET_BASES_COUNT; i++)
{
if (bases[i].language == LANGUAGE_JAPANESE)
ClearSecretBase(&bases[i]);
}
}
void InitSecretBaseVars(void)
{
VarSet(VAR_SECRET_BASE_STEP_COUNTER, 0);
VarSet(VAR_SECRET_BASE_LAST_ITEM_USED, 0);
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, 0);
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, 0);
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_IS_NOT_LOCAL, TRUE);
else
VarSet(VAR_SECRET_BASE_IS_NOT_LOCAL, FALSE);
sInFriendSecretBase = FALSE;
}
void CheckLeftFriendsSecretBase(void)
{
if (VarGet(VAR_SECRET_BASE_IS_NOT_LOCAL) && sInFriendSecretBase == TRUE && !CurMapIsSecretBase())
{
VarSet(VAR_SECRET_BASE_IS_NOT_LOCAL, FALSE);
sInFriendSecretBase = FALSE;
TryPutSecretBaseSecretsOnAir();
VarSet(VAR_SECRET_BASE_STEP_COUNTER, 0);
VarSet(VAR_SECRET_BASE_LAST_ITEM_USED, 0);
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, 0);
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, 0);
VarSet(VAR_SECRET_BASE_IS_NOT_LOCAL, FALSE);
}
}
void CheckInteractedWithFriendsDollDecor(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_DOLL);
}
void CheckInteractedWithFriendsCushionDecor(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_CUSHION);
}
void DeclinedSecretBaseBattle(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
{
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) & ~(SECRET_BASE_BATTLED_WON | SECRET_BASE_BATTLED_LOST | SECRET_BASE_DECLINED_BATTLE));
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) & ~(SECRET_BASE_BATTLED_DRAW));
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_DECLINED_BATTLE);
}
}
void WonSecretBaseBattle(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
{
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) & ~(SECRET_BASE_BATTLED_WON | SECRET_BASE_BATTLED_LOST | SECRET_BASE_DECLINED_BATTLE));
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) & ~(SECRET_BASE_BATTLED_DRAW));
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_BATTLED_WON);
}
}
void LostSecretBaseBattle(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
{
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) & ~(SECRET_BASE_BATTLED_WON | SECRET_BASE_BATTLED_LOST | SECRET_BASE_DECLINED_BATTLE));
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) & ~(SECRET_BASE_BATTLED_DRAW));
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_BATTLED_LOST);
}
}
void DrewSecretBaseBattle(void)
{
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
{
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) & ~(SECRET_BASE_BATTLED_WON | SECRET_BASE_BATTLED_LOST | SECRET_BASE_DECLINED_BATTLE));
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) & ~(SECRET_BASE_BATTLED_DRAW));
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_BATTLED_DRAW);
}
}
void CheckInteractedWithFriendsPosterDecor(void)
{
s16 x, y;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
switch (MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_PikaPoster_Left:
case METATILE_SecretBase_PikaPoster_Right:
case METATILE_SecretBase_LongPoster_Left:
case METATILE_SecretBase_LongPoster_Right:
case METATILE_SecretBase_SeaPoster_Left:
case METATILE_SecretBase_SeaPoster_Right:
case METATILE_SecretBase_SkyPoster_Left:
case METATILE_SecretBase_SkyPoster_Right:
case METATILE_SecretBase_KissPoster_Left:
case METATILE_SecretBase_KissPoster_Right:
case METATILE_SecretBase_BallPoster:
case METATILE_SecretBase_GreenPoster:
case METATILE_SecretBase_RedPoster:
case METATILE_SecretBase_BluePoster:
case METATILE_SecretBase_CutePoster:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_POSTER);
break;
}
}
void CheckInteractedWithFriendsFurnitureBottom(void)
{
s16 x, y;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
switch (MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_GlassOrnament_Base1:
case METATILE_SecretBase_GlassOrnament_Base2:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_GLASS_ORNAMENT);
break;
case METATILE_SecretBase_RedPlant_Base1:
case METATILE_SecretBase_RedPlant_Base2:
case METATILE_SecretBase_TropicalPlant_Base1:
case METATILE_SecretBase_TropicalPlant_Base2:
case METATILE_SecretBase_PrettyFlowers_Base1:
case METATILE_SecretBase_PrettyFlowers_Base2:
case METATILE_SecretBase_ColorfulPlant_BaseLeft1:
case METATILE_SecretBase_ColorfulPlant_BaseRight1:
case METATILE_SecretBase_ColorfulPlant_BaseLeft2:
case METATILE_SecretBase_ColorfulPlant_BaseRight2:
case METATILE_SecretBase_BigPlant_BaseLeft1:
case METATILE_SecretBase_BigPlant_BaseRight1:
case METATILE_SecretBase_BigPlant_BaseLeft2:
case METATILE_SecretBase_BigPlant_BaseRight2:
case METATILE_SecretBase_GorgeousPlant_BaseLeft1:
case METATILE_SecretBase_GorgeousPlant_BaseRight1:
case METATILE_SecretBase_GorgeousPlant_BaseLeft2:
case METATILE_SecretBase_GorgeousPlant_BaseRight2:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_LOW_TV_FLAGS, VarGet(VAR_SECRET_BASE_LOW_TV_FLAGS) | SECRET_BASE_USED_PLANT);
break;
case METATILE_SecretBase_Fence_Horizontal:
case METATILE_SecretBase_Fence_Vertical:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_FENCE);
break;
case METATILE_SecretBase_Tire_BottomLeft:
case METATILE_SecretBase_Tire_BottomRight:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_TIRE);
break;
case METATILE_SecretBase_RedBrick_Bottom:
case METATILE_SecretBase_YellowBrick_Bottom:
case METATILE_SecretBase_BlueBrick_Bottom:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_BRICK);
break;
case METATILE_SecretBase_SmallDesk:
case METATILE_SecretBase_PokemonDesk:
case METATILE_SecretBase_HeavyDesk_BottomLeft:
case METATILE_SecretBase_HeavyDesk_BottomMid:
case METATILE_SecretBase_HeavyDesk_BottomRight:
case METATILE_SecretBase_RaggedDesk_BottomLeft:
case METATILE_SecretBase_RaggedDesk_BottomMid:
case METATILE_SecretBase_RaggedDesk_BottomRight:
case METATILE_SecretBase_ComfortDesk_BottomLeft:
case METATILE_SecretBase_ComfortDesk_BottomMid:
case METATILE_SecretBase_ComfortDesk_BottomRight:
case METATILE_SecretBase_BrickDesk_BottomLeft:
case METATILE_SecretBase_BrickDesk_BottomMid:
case METATILE_SecretBase_BrickDesk_BottomRight:
case METATILE_SecretBase_CampDesk_BottomLeft:
case METATILE_SecretBase_CampDesk_BottomMid:
case METATILE_SecretBase_CampDesk_BottomRight:
case METATILE_SecretBase_HardDesk_BottomLeft:
case METATILE_SecretBase_HardDesk_BottomMid:
case METATILE_SecretBase_HardDesk_BottomRight:
case METATILE_SecretBase_PrettyDesk_BottomLeft:
case METATILE_SecretBase_PrettyDesk_BottomMid:
case METATILE_SecretBase_PrettyDesk_BottomRight:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_DESK);
break;
}
}
void CheckInteractedWithFriendsFurnitureMiddle(void)
{
s16 x, y;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
switch (MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_HeavyDesk_TopMid:
case METATILE_SecretBase_RaggedDesk_TopMid:
case METATILE_SecretBase_ComfortDesk_TopMid:
case METATILE_SecretBase_BrickDesk_TopMid:
case METATILE_SecretBase_BrickDesk_Center:
case METATILE_SecretBase_CampDesk_TopMid:
case METATILE_SecretBase_CampDesk_Center:
case METATILE_SecretBase_HardDesk_TopMid:
case METATILE_SecretBase_HardDesk_Center:
case METATILE_SecretBase_PrettyDesk_TopMid:
case METATILE_SecretBase_PrettyDesk_Center:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_DESK);
break;
}
}
void CheckInteractedWithFriendsFurnitureTop(void)
{
s16 x, y;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
switch (MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_HeavyDesk_TopLeft:
case METATILE_SecretBase_HeavyDesk_TopRight:
case METATILE_SecretBase_RaggedDesk_TopLeft:
case METATILE_SecretBase_RaggedDesk_TopRight:
case METATILE_SecretBase_ComfortDesk_TopLeft:
case METATILE_SecretBase_ComfortDesk_TopRight:
case METATILE_SecretBase_BrickDesk_TopLeft:
case METATILE_SecretBase_BrickDesk_TopRight:
case METATILE_SecretBase_BrickDesk_MidLeft:
case METATILE_SecretBase_BrickDesk_MidRight:
case METATILE_SecretBase_CampDesk_TopLeft:
case METATILE_SecretBase_CampDesk_TopRight:
case METATILE_SecretBase_CampDesk_MidLeft:
case METATILE_SecretBase_CampDesk_MidRight:
case METATILE_SecretBase_HardDesk_TopLeft:
case METATILE_SecretBase_HardDesk_TopRight:
case METATILE_SecretBase_HardDesk_MidLeft:
case METATILE_SecretBase_HardDesk_MidRight:
case METATILE_SecretBase_PrettyDesk_TopLeft:
case METATILE_SecretBase_PrettyDesk_TopRight:
case METATILE_SecretBase_PrettyDesk_MidLeft:
case METATILE_SecretBase_PrettyDesk_MidRight:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_DESK);
break;
case METATILE_SecretBase_Tire_TopLeft:
case METATILE_SecretBase_Tire_TopRight:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_TIRE);
break;
case METATILE_SecretBase_RedBrick_Top:
case METATILE_SecretBase_YellowBrick_Top:
case METATILE_SecretBase_BlueBrick_Top:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_BRICK);
break;
}
}
void CheckInteractedWithFriendsSandOrnament(void)
{
s16 x, y;
GetXYCoordsOneStepInFrontOfPlayer(&x, &y);
switch ((int)MapGridGetMetatileIdAt(x, y))
{
case METATILE_SecretBase_SandOrnament_Base1:
case METATILE_SecretBase_SandOrnament_Base2:
if (VarGet(VAR_CURRENT_SECRET_BASE) != 0)
VarSet(VAR_SECRET_BASE_HIGH_TV_FLAGS, VarGet(VAR_SECRET_BASE_HIGH_TV_FLAGS) | SECRET_BASE_USED_SAND_ORNAMENT);
break;
}
}
Reference in New Issue Copy Permalink