Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-03-21 09:45:26 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

more trainer card documentation (#647)

Browse Source
This commit is contained in:
scbroede 2025-07-30 00:07:51 -04:00 committed by GitHub
parent 523478194f
commit 9fddd04a57
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
59 changed files with 2080 additions and 2105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-format
View File

@ -53,6 +53,9 @@ IndentGotoLabels: false
IndentPPDirectives: None
IndentWidth: 4
Macros:
- FX32_ONE=0x0000000000001000L
SortIncludes: CaseSensitive
IncludeBlocks: Regroup
IncludeCategories:

10
include/overlay071/ov71_0223B140.h
View File

@ -1,10 +0,0 @@
#ifndef POKEPLATINUM_OV71_0223B140_H
#define POKEPLATINUM_OV71_0223B140_H
#include "overlay_manager.h"
int ov71_0223B140(ApplicationManager *appMan, int *param1);
int ov71_0223B388(ApplicationManager *appMan, int *param1);
int ov71_0223B5B8(ApplicationManager *appMan, int *param1);
#endif // POKEPLATINUM_OV71_0223B140_H

13
include/overlay071/ov71_0223CF0C.h
View File

@ -1,13 +0,0 @@
#ifndef POKEPLATINUM_OV71_0223CF0C_H
#define POKEPLATINUM_OV71_0223CF0C_H
#include "overlay071/struct_ov71_0223D238.h"
#include "narc.h"
void ov71_0223CF0C(UnkStruct_ov71_0223D238 *param0, NARC *param1);
void ov71_0223D070(UnkStruct_ov71_0223D238 *param0, const u8 *param1);
void ov71_0223D238(UnkStruct_ov71_0223D238 *param0);
void ov71_0223D298(UnkStruct_ov71_0223D238 *param0, const u8 param1, const u8 param2);
#endif // POKEPLATINUM_OV71_0223CF0C_H

9
include/overlay071/ov71_0223D324.h
View File

@ -1,9 +0,0 @@
#ifndef POKEPLATINUM_OV71_0223D324_H
#define POKEPLATINUM_OV71_0223D324_H
#include "overlay071/struct_ov71_0223D324.h"
void ov71_0223D324(UnkStruct_ov71_0223D324 *param0);
void ov71_0223D338(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2);
#endif // POKEPLATINUM_OV71_0223D324_H

66
include/overlay071/struct_ov71_0223B620.h
View File

@ -1,66 +0,0 @@
#ifndef POKEPLATINUM_STRUCT_OV71_0223B620_H
#define POKEPLATINUM_STRUCT_OV71_0223B620_H
#include <nnsys.h>
#include "overlay071/struct_ov71_0223C444.h"
#include "overlay071/struct_ov71_0223D238.h"
#include "overlay071/struct_ov71_0223D324.h"
#include "bg_window.h"
#include "strbuf.h"
#include "trainer_card.h"
enum TrainerCardWindows {
TRAINER_CARD_WINDOW_ID,
TRAINER_CARD_WINDOW_NAME,
TRAINER_CARD_WINDOW_MONEY,
TRAINER_CARD_WINDOW_POKEDEX,
TRAINER_CARD_WINDOW_SCORE,
TRAINER_CARD_WINDOW_TIME,
TRAINER_CARD_WINDOW_ADVENTURE_STARTED,
TRAINER_CARD_WINDOW_HOF_DEBUT,
TRAINER_CARD_WINDOW_TIMES_LINKED,
TRAINER_CARD_WINDOW_LINK_BATTLES,
TRAINER_CARD_WINDOW_LINK_TRADES,
TRAINER_CARD_WINDOW_COUNT
};
typedef struct {
BgConfig *bgConfig;
Window windows[TRAINER_CARD_WINDOW_COUNT];
TrainerCard *trainerCard;
u8 unk_B8[12288];
void *unk_30B8;
NNSG2dCharacterData *unk_30BC;
BOOL unk_30C0;
BOOL unk_30C4;
fx32 unk_30C8;
fx32 unk_30CC;
fx32 unk_30D0;
int unk_30D4;
BOOL unk_30D8;
int unk_30DC;
int unk_30E0;
UnkStruct_ov71_0223D238 unk_30E4;
int unk_3348;
int unk_334C;
BOOL unk_3350;
UnkStruct_ov71_0223D324 unk_3354;
void *unk_335C;
NNSG2dScreenData *unk_3360;
UnkStruct_ov71_0223C444 unk_3364;
Strbuf *unusedStrbuf;
Strbuf *colonStrbuf;
u8 unk_3374[8];
u8 unk_337C;
u8 unk_337D;
u8 unk_337E;
u8 unk_337F;
u8 unk_3380;
u8 unk_3381;
u8 unk_3382;
u8 unk_3383;
} UnkStruct_ov71_0223B620;
#endif // POKEPLATINUM_STRUCT_OV71_0223B620_H

12
include/overlay071/struct_ov71_0223C444.h
View File

@ -1,12 +0,0 @@
#ifndef POKEPLATINUM_STRUCT_OV71_0223C444_H
#define POKEPLATINUM_STRUCT_OV71_0223C444_H
typedef struct {
s8 unk_00;
s8 unk_01;
s8 unk_02;
s8 unk_03;
u8 unk_04;
} UnkStruct_ov71_0223C444;
#endif // POKEPLATINUM_STRUCT_OV71_0223C444_H

20
include/overlay071/struct_ov71_0223D238.h
View File

@ -1,20 +0,0 @@
#ifndef POKEPLATINUM_STRUCT_OV71_0223D238_H
#define POKEPLATINUM_STRUCT_OV71_0223D238_H
#include <nnsys.h>
#include "sprite.h"
#include "sprite_resource.h"
#include "sprite_util.h"
typedef struct {
SpriteList *unk_00;
G2dRenderer unk_04;
SpriteResourceCollection *unk_190[4];
SpriteResource *unk_1A0[2][4];
Sprite *unk_1C0[25];
void *unk_224[8];
NNSG2dPaletteData *unk_244[8];
} UnkStruct_ov71_0223D238;
#endif // POKEPLATINUM_STRUCT_OV71_0223D238_H

8
include/overlay071/struct_ov71_0223D324.h
View File

@ -1,8 +0,0 @@
#ifndef POKEPLATINUM_STRUCT_OV71_0223D324_H
#define POKEPLATINUM_STRUCT_OV71_0223D324_H
typedef struct {
u8 unk_00[4][2];
} UnkStruct_ov71_0223D324;
#endif // POKEPLATINUM_STRUCT_OV71_0223D324_H

4
include/screen_fade.h
View File

@ -29,8 +29,8 @@ enum FadeType {
FADE_TYPE_BRIGHTNESS_OUT = 0,
FADE_TYPE_BRIGHTNESS_IN,
FADE_TYPE_UNK_2,
FADE_TYPE_UNK_3,
FADE_TYPE_UNK_4,
FADE_TYPE_DOWNWARD_IN,
FADE_TYPE_UPWARD_OUT,
FADE_TYPE_UNK_5,
FADE_TYPE_UNK_6,
FADE_TYPE_UNK_7,

5
include/sound.h
View File

@ -29,6 +29,11 @@
#define WAVE_OUT_PAN_CENTER 64
#define WAVE_OUT_PAN_RIGHT 127
#define SOUND_PLAYBACK_TRACK(TRACK) (1 << (TRACK))
#define SOUND_PLAYBACK_TRACK_ALL 0xFFFF
#define NUM_SE_PLAYERS PLAYER_SE_4 - PLAYER_SE_1 + 1
enum SoundScene {
SOUND_SCENE_NONE = 0,
SOUND_SCENE_TITLE_SCREEN,

3
include/sound_playback.h
View File

@ -6,9 +6,6 @@
#include "sound_system.h"
#define SOUND_PLAYBACK_TRACK(TRACK) (1 << (TRACK))
#define SOUND_PLAYBACK_TRACK_ALL 0xFFFF
enum BGMFadeInType {
BGM_FADE_IN_TYPE_FROM_ZERO = 0, // Fade in from volume 0
BGM_FADE_IN_TYPE_FROM_CURRENT = 1, // Fade in from the current volume

44
include/trainer_card.h
View File

@ -5,25 +5,34 @@
#include "field/field_system_decl.h"
#include "badges.h"
#include "play_time.h"
typedef struct {
int unk_00_0 : 1;
int unk_00_1 : 31;
} TrainerCard_sub1;
#define SIGNATURE_WIDTH 24
#define SIGNATURE_HEIGHT 8
#define BADGE_POLISH_THRESHOLD_DIRTY 100
#define BADGE_POLISH_THRESHOLD_NORMAL 140
#define BADGE_POLISH_THRESHOLD_2_SPARKLES 170
#define BADGE_POLISH_THRESHOLD_4_SPARKLES 190
#define MAX_BADGE_POLISH 199
typedef struct TrainerCardBadge {
int obtained : 1;
int polish : 31;
} TrainerCardBadge;
typedef struct TrainerCard {
u8 gameVersion;
u8 regionCode;
u8 unk_02;
u8 gymLeadersToHide_Unused;
u8 stars;
u8 unk_04_0 : 1;
u8 unk_04_1 : 1;
u8 badgesInteractable : 1;
u8 liveTimeDisplay : 1;
u8 gender : 1;
u8 pokedexObtained : 1;
u8 padding_04_4 : 4;
u8 unk_05;
u8 padding_06[2];
u8 trainerAppearance;
u8 padding[2];
u16 name[TRAINER_NAME_LEN + 1];
const PlayTime *playTime;
u32 money;
@ -40,22 +49,21 @@ typedef struct TrainerCard {
u8 hofDebutMonth;
u8 hofDebutDay;
u8 hofDebutMinute;
u8 padding_36[2];
u32 timesLinked;
u32 linkBattleWins;
u32 linkBattleLosses;
u32 linkTrades;
TrainerCard_sub1 unk_48[8];
u8 signature[1536];
u16 checksum;
TrainerCardBadge badges[MAX_BADGES];
u8 signature[SIGNATURE_WIDTH * SIGNATURE_HEIGHT * 8];
u16 checksum; // calculated but never used for anything
u16 unk_66A;
} TrainerCard;
void TrainerCard_Init(const u8 param0, const u8 param1, const u8 param2, const u8 param3, FieldSystem *fieldSystem, TrainerCard *trainerCard);
TrainerCard *TrainerCard_New(const u16 headID);
void TrainerCard_Init(u8 param0, u8 param1, u8 gymLeadersToHide, u8 trainerAppearance, FieldSystem *fieldSystem, TrainerCard *trainerCard);
TrainerCard *TrainerCard_New(u16 heapID);
void TrainerCard_Free(TrainerCard *trainerCard);
u8 TrainerCard_CalculateStars(FieldSystem *fieldSystem);
void sub_020721D4(FieldSystem *fieldSystem, const TrainerCard *trainerCard);
void TrainerCard_SaveBadgePolish(FieldSystem *fieldSystem, const TrainerCard *trainerCard);
void sub_02072204(FieldSystem *fieldSystem);
#endif // POKEPLATINUM_trainer_card_H
#endif // POKEPLATINUM_TRAINER_CARD_H

8
include/trainer_card_badge_dirt.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef POKEPLATINUM_TRAINER_CARD_BADGE_DIRT_H
#define POKEPLATINUM_TRAINER_CARD_BADGE_DIRT_H
#include "savedata.h"
void TrainerCard_AccumulateBadgeDirt(SaveData *saveData, s32 daysPassed);
#endif // POKEPLATINUM_TRAINER_CARD_BADGE_DIRT_H

17
include/trainer_card_save_data.h
View File

@ -3,22 +3,23 @@
#include "badges.h"
#include "savedata.h"
#include "trainer_card.h"
typedef struct TrainerCardBadge {
int cleanliness;
} TrainerCardBadge;
typedef struct TrainerCardSaveDataBadge {
int polish;
} TrainerCardSaveDataBadge;
typedef struct TrainerCardSaveData {
TrainerCardBadge badges[MAX_BADGES];
u8 signature[1536];
TrainerCardSaveDataBadge badges[MAX_BADGES];
u8 signature[SIGNATURE_WIDTH * SIGNATURE_HEIGHT * 8];
} TrainerCardSaveData;
int TrainerCardSaveData_Size(void);
void TrainerCardSaveData_Init(TrainerCardSaveData *tcSaveData);
TrainerCardSaveData *SaveData_GetTrainerCardSaveData(SaveData *saveData);
u8 *TrainerCardSaveData_GetSignature(TrainerCardSaveData *tcSaveData);
TrainerCardBadge *TrainerCardSaveData_GetTrainerCardBadges(TrainerCardSaveData *tcSaveData);
int TrainerCardBadge_GetCleanliness(const u8 badgeID, TrainerCardBadge *badges);
void TrainerCardBadge_SetCleanliness(const u8 badgeID, const int cleanliness, TrainerCardBadge *badges);
TrainerCardSaveDataBadge *TrainerCardSaveData_GetTrainerCardSaveDataBadges(TrainerCardSaveData *tcSaveData);
int TrainerCardSaveDataBadge_GetPolish(u8 badgeID, TrainerCardSaveDataBadge *badges);
void TrainerCardSaveDataBadge_SetPolish(u8 badgeID, int polish, TrainerCardSaveDataBadge *badges);
#endif // POKEPLATINUM_TRAINERCARD_SAVEDATA_H

9
include/trainer_card_screen/trainer_card_badge_chimes.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef POKEPLATINUM_TRAINERCARD_BADGE_CHIMES_H
#define POKEPLATINUM_TRAINERCARD_BADGE_CHIMES_H
#include "trainer_card_screen/trainer_card_screen_defs.h"
void TrainerCard_InitBadgeChimeState(TrainerCardBadgeChimeState *badgeChimeState);
void TrainerCard_PlayBadgeChime(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel);
#endif // POKEPLATINUM_TRAINERCARD_BADGE_CHIMES_H

0
include/overlay071/trainer_card_display_text.h → include/trainer_card_screen/trainer_card_display_text.h
View File

10
include/trainer_card_screen/trainer_card_screen.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef POKEPLATINUM_TRAINERCARD_SCREEN_H
#define POKEPLATINUM_TRAINERCARD_SCREEN_H
#include "overlay_manager.h"
BOOL TrainerCardScreen_Init(ApplicationManager *appMan, int *state);
BOOL TrainerCardScreen_Main(ApplicationManager *appMan, int *state);
BOOL TrainerCardScreen_Exit(ApplicationManager *appMan, int *state);
#endif // POKEPLATINUM_TRAINERCARD_SCREEN_H

97
include/trainer_card_screen/trainer_card_screen_defs.h Normal file
View File

@ -0,0 +1,97 @@
#ifndef POKEPLATINUM_STRUCT_TRAINERCARD_SCREEN_H
#define POKEPLATINUM_STRUCT_TRAINERCARD_SCREEN_H
#include <nnsys.h>
#include "badges.h"
#include "bg_window.h"
#include "sound.h"
#include "sprite.h"
#include "sprite_resource.h"
#include "sprite_util.h"
#include "strbuf.h"
#include "trainer_card.h"
enum TrainerCardWindows {
TRAINER_CARD_WINDOW_ID,
TRAINER_CARD_WINDOW_NAME,
TRAINER_CARD_WINDOW_MONEY,
TRAINER_CARD_WINDOW_POKEDEX,
TRAINER_CARD_WINDOW_SCORE,
TRAINER_CARD_WINDOW_TIME,
TRAINER_CARD_WINDOW_ADVENTURE_STARTED,
TRAINER_CARD_WINDOW_HOF_DEBUT,
TRAINER_CARD_WINDOW_TIMES_LINKED,
TRAINER_CARD_WINDOW_LINK_BATTLES,
TRAINER_CARD_WINDOW_LINK_TRADES,
TRAINER_CARD_WINDOW_COUNT
};
enum BadgePolishLevels {
BADGE_POLISH_LEVEL_FILTHY,
BADGE_POLISH_LEVEL_DIRTY,
BADGE_POLISH_LEVEL_NORMAL,
BADGE_POLISH_LEVEL_2_SPARKLES,
BADGE_POLISH_LEVEL_4_SPARKLES,
BADGE_POLISH_LEVEL_COUNT
};
typedef struct BadgePolishingState {
s8 previousXDirection;
s8 previousYDirection;
s8 currentXDirection;
s8 currentYDirection;
u8 soundEffectIndex;
} BadgePolishingState;
typedef struct TrainerCardBadgeChimeState {
u8 badgeChimePlayers[NUM_SE_PLAYERS][2];
} TrainerCardBadgeChimeState;
typedef struct TrainerCardSpriteData {
SpriteList *spriteList;
G2dRenderer g2dRenderer;
SpriteResourceCollection *spriteResourceCollection[4];
SpriteResource *spriteResources[2][4];
Sprite *sprites[MAX_BADGES * 3 + 1];
void *badgePaletteBuffers[MAX_BADGES];
NNSG2dPaletteData *badgePalettes[MAX_BADGES];
} TrainerCardSpriteData;
typedef struct TrainerCardScreen {
BgConfig *bgConfig;
Window windows[TRAINER_CARD_WINDOW_COUNT];
TrainerCard *trainerCard;
u8 signature[SIGNATURE_WIDTH * SIGNATURE_HEIGHT * TILE_SIZE_8BPP];
void *trainerSprite;
NNSG2dCharacterData *trainerCharacterData;
BOOL viewingBack;
BOOL polishingEnabled;
fx32 cardXScale;
fx32 cardYScale;
fx32 badgeCaseCoverYScale;
int touchedRectangleIndex;
BOOL badgeCaseCoverMoving;
int lastTouchedX;
int lastTouchedY;
TrainerCardSpriteData spriteData;
int cardScalingSpeed;
int unused;
BOOL badgeCaseButtonPushed;
TrainerCardBadgeChimeState badgeChimeState;
void *trainerScreenDataNSCRBuffer;
NNSG2dScreenData *trainerScreenData;
BadgePolishingState badgePolishingState;
Strbuf *unusedStrbuf;
Strbuf *colonStrbuf;
u8 polishingProgress[MAX_BADGES];
u8 badgeCaseOpenState;
u8 badgeCaseTransitionIndex;
u8 subState;
u8 badgeCaseButtonAnimTimer;
u8 badgeCaseButtonAnimIndex;
u8 badgeCaseButtonState;
u8 timer;
} TrainerCardScreen;
#endif // POKEPLATINUM_STRUCT_TRAINERCARD_SCREEN_H

17
include/trainer_card_screen/trainer_card_sprites.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef POKEPLATINUM_TRAINERCARD_SPRITES_H
#define POKEPLATINUM_TRAINERCARD_SPRITES_H
#include "trainer_card_screen/trainer_card_screen_defs.h"
#include "narc.h"
#define TRAINER_CARD_TWO_SPARKLES_SPRITES_INDEX 8
#define TRAINER_CARD_FOUR_SPARKLES_SPRITES_INDEX 16
#define TRAINER_CARD_BADGE_CASE_BUTTON_EFFECT_SPRITE_INDEX 24
void TrainerCard_InitSpriteData(TrainerCardSpriteData *spriteData, NARC *narc);
void TrainerCard_DrawBadgeCaseSprites(TrainerCardSpriteData *spriteData, u8 *badgesObtained);
void TrainerCard_FreeSprites(TrainerCardSpriteData *spriteData);
void TrainerCard_DrawBadgeDirt(TrainerCardSpriteData *spriteData, u8 badgeID, u8 dirtLevel);
#endif // POKEPLATINUM_TRAINERCARD_SPRITES_H

2
include/unk_0203D1B8.h
View File

@ -68,7 +68,7 @@ void *sub_0203DE34(FieldSystem *fieldSystem);
void sub_0203DE78(FieldSystem *fieldSystem, SaveData *saveData);
void sub_0203DE88(FieldSystem *fieldSystem, SaveData *saveData);
void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int param4, const u16 *param5, u16 *param6);
void sub_0203E09C(FieldSystem *fieldSystem, TrainerCard *param1);
void FieldSystem_OpenTrainerCardScreen(FieldSystem *fieldSystem, TrainerCard *param1);
BOOL sub_0203E0AC(FieldSystem *fieldSystem, void *param1);
void FieldSystem_LaunchChooseStarterApp(FieldSystem *fieldSystem, ChooseStarterData *param1);
void sub_0203E0D0(FieldSystem *fieldSystem);

8
include/unk_0206C2D0.h
View File

@ -1,8 +0,0 @@
#ifndef POKEPLATINUM_UNK_0206C2D0_H
#define POKEPLATINUM_UNK_0206C2D0_H
#include "savedata.h"
void sub_0206C2D0(SaveData *saveData, const s32 param1);
#endif // POKEPLATINUM_UNK_0206C2D0_H

14
platinum.us/main.lsf
View File

@ -269,7 +269,7 @@ Static main
Object main.nef.p/src_unk_0206B70C.c.o
Object main.nef.p/src_unk_0206B9D8.c.o
Object main.nef.p/src_great_marsh_lookout.c.o
Object main.nef.p/src_unk_0206C2D0.c.o
Object main.nef.p/src_trainer_card_badge_dirt.c.o
Object main.nef.p/src_roaming_pokemon.c.o
Object main.nef.p/src_unk_0206C660.c.o
Object main.nef.p/src_unk_0206C784.c.o
@ -1244,18 +1244,18 @@ Overlay overlay70
Object main.nef.p/src_overlay070_ov70_0226CE54.c.o
}
Overlay overlay71
Overlay trainer_card_screen
{
After overlay12
Object main.nef.p/src_overlay071_ov71_0223B140.c.o
Object main.nef.p/src_overlay071_trainer_card_display_text.c.o
Object main.nef.p/src_overlay071_ov71_0223CF0C.c.o
Object main.nef.p/src_overlay071_ov71_0223D324.c.o
Object main.nef.p/src_trainer_card_screen_trainer_card_screen.c.o
Object main.nef.p/src_trainer_card_screen_trainer_card_display_text.c.o
Object main.nef.p/src_trainer_card_screen_trainer_card_sprites.c.o
Object main.nef.p/src_trainer_card_screen_trainer_card_badge_chimes.c.o
}
Overlay overlay72
{
After overlay71
After trainer_card_screen
Object main.nef.p/src_overlay072_ov72_0223D7A0.c.o
}

2
platinum.us/sbins_shared.sha1
View File

@ -70,7 +70,7 @@ d2a6ce95570f7eddb8cbfbe0fd8317d54c48cb1d *overlay64.sbin
6c90858a9f97833957e94da68513a90b7ea16dfa *overlay68.sbin
c655f6874e4e9897f3f0782af1140cedd97154da *overlay69.sbin
b80c7e652b63a37f2a30b9c0f14d6e5608185d05 *overlay70.sbin
cf86b18a15a2b011fd0e7c98379a9fa228c3fc4c *overlay71.sbin
cf86b18a15a2b011fd0e7c98379a9fa228c3fc4c *trainer_card_screen.sbin
39a79a31811cac6b1a90206e67624c0a3179bd46 *overlay72.sbin
deecf01a5608b25883804ef30c9d4c3d0c904ee5 *rowan_intro.sbin
21e3d2a2fb36d739f4fd16792719bf6fa7b7e6aa *options_menu.sbin

2
src/field_comm_manager.c
View File

@ -180,7 +180,7 @@ void FieldCommMan_EnterBattleRoom(FieldSystem *fieldSystem)
}
}
TrainerCard_Init(0, 0, 0, 0xff, sFieldCommMan->fieldSystem, sFieldCommMan->trainerCard[netId]);
TrainerCard_Init(FALSE, FALSE, 0, 0xFF, sFieldCommMan->fieldSystem, sFieldCommMan->trainerCard[netId]);
}
CommTiming_StartSync(95);

10
src/meson.build
View File

@ -255,7 +255,7 @@ pokeplatinum_c = files(
'unk_0206B70C.c',
'unk_0206B9D8.c',
'great_marsh_lookout.c',
'unk_0206C2D0.c',
'trainer_card_badge_dirt.c',
'roaming_pokemon.c',
'unk_0206C660.c',
'unk_0206C784.c',
@ -797,10 +797,10 @@ pokeplatinum_c = files(
'overlay070/ov70_0226C8B4.c',
'overlay070/ov70_0226CC74.c',
'overlay070/ov70_0226CE54.c',
'overlay071/ov71_0223B140.c',
'overlay071/trainer_card_display_text.c',
'overlay071/ov71_0223CF0C.c',
'overlay071/ov71_0223D324.c',
'trainer_card_screen/trainer_card_screen.c',
'trainer_card_screen/trainer_card_display_text.c',
'trainer_card_screen/trainer_card_sprites.c',
'trainer_card_screen/trainer_card_badge_chimes.c',
'overlay072/ov72_0223D7A0.c',
'applications/rowan_intro/rowan_intro_app.c',
'applications/rowan_intro/tv_app.c',

4
src/overlay005/map_prop.c
View File

@ -132,7 +132,7 @@ void MapPropManager_Render(const VecFx32 *positionOffset, const AreaDataManager
0,
0,
0,
FX32_ONE
FX32_ONE,
};
for (int i = 0; i < MAX_LOADED_MAP_PROPS; i++) {
@ -312,7 +312,7 @@ void MapPropManager_Render2(MapPropManager *mapPropManager, AreaDataManager *con
0,
0,
0,
FX32_ONE
FX32_ONE,
};
for (u8 i = 0; i < MAX_LOADED_MAP_PROPS; i++) {

2
src/overlay005/ov5_021F134C.c
View File

@ -387,7 +387,7 @@ static const fx32 Unk_ov5_02200284[] = {
FX32_ONE * 18,
FX32_ONE * 18,
FX32_ONE * 8,
FX32_ONE * 4
FX32_ONE * 4,
};
static const int Unk_ov5_02200278[3] = {

2
src/overlay006/ov6_02242AF0.c
View File

@ -79,7 +79,7 @@ static const fx32 Unk_ov6_02249074[] = {
FX32_ONE * 2,
FX32_ONE * 2,
FX32_ONE * 1,
FX32_ONE / 2
FX32_ONE / 2,
};
void GreatMarsh_DynamicMapFeaturesInit(FieldSystem *fieldSystem)

14
src/overlay008/ov8_02249960.c
View File

@ -2264,12 +2264,16 @@ static const u32 Unk_ov8_0224C700[2] = {
};
static const VecFx32 Unk_ov8_0224C7A0[2] = {
{ ((11 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
{
((11 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
FX32_ONE * 12,
((13 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1) },
{ ((11 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
(FX32_ONE * 13),
((13 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1) }
((13 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
},
{
((11 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
FX32_ONE * 13,
((13 << 4) * FX32_ONE) + ((16 * FX32_ONE) >> 1),
}
};
static const u16 Unk_ov8_0224C7B8[12] = {

1
src/overlay012/battle_anim_system.c
View File

@ -38,6 +38,7 @@
#include "pltt_transfer.h"
#include "pokemon.h"
#include "pokemon_sprite.h"
#include "sound.h"
#include "sound_playback.h"
#include "spl.h"
#include "sprite.h"

1341
src/overlay071/ov71_0223B140.c
View File

File diff suppressed because it is too large Load Diff

229
src/overlay071/ov71_0223CF0C.c
View File

@ -1,229 +0,0 @@
#include "overlay071/ov71_0223CF0C.h"
#include <nitro.h>
#include <string.h>
#include "overlay071/struct_ov71_0223D238.h"
#include "char_transfer.h"
#include "gx_layers.h"
#include "heap.h"
#include "narc.h"
#include "pltt_transfer.h"
#include "render_oam.h"
#include "sprite.h"
#include "sprite_resource.h"
#include "sprite_transfer.h"
#include "sprite_util.h"
typedef struct {
int unk_00;
int unk_04;
} UnkStruct_ov71_0223D73C;
static const u8 Unk_ov71_0223D6C8[4] = {
0x1,
0x2,
0x1,
0x1
};
static const UnkStruct_ov71_0223D73C Unk_ov71_0223D73C[] = {
{ 0x18, 0x28 },
{ 0x50, 0x28 },
{ 0x88, 0x28 },
{ 0xC0, 0x28 },
{ 0x18, 0x48 },
{ 0x50, 0x48 },
{ 0x88, 0x48 },
{ 0xC0, 0x48 }
};
static const UnkStruct_ov71_0223D73C Unk_ov71_0223D6FC[] = {
{ 0x18, 0x28 },
{ 0x50, 0x28 },
{ 0x88, 0x28 },
{ 0xC0, 0x28 },
{ 0x18, 0x60 },
{ 0x50, 0x60 },
{ 0x88, 0x60 },
{ 0xC0, 0x60 }
};
static void ov71_0223D2F4(void);
void ov71_0223CF0C(UnkStruct_ov71_0223D238 *param0, NARC *param1)
{
int v0;
ov71_0223D2F4();
NNS_G2dInitOamManagerModule();
RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, 25);
param0->unk_00 = SpriteList_InitRendering((8 + 8 + 8 + 1), &param0->unk_04, HEAP_ID_TRAINER_CARD_SCREEN);
for (v0 = 0; v0 < 4; v0++) {
param0->unk_190[v0] = SpriteResourceCollection_New(Unk_ov71_0223D6C8[v0], v0, HEAP_ID_TRAINER_CARD_SCREEN);
}
param0->unk_1A0[0][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_190[0], param1, 33, 0, 1, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_TRAINER_CARD_SCREEN);
param0->unk_1A0[0][1] = SpriteResourceCollection_AddPaletteFrom(param0->unk_190[1], param1, 14, 0, 1, NNS_G2D_VRAM_TYPE_2DMAIN, 9, HEAP_ID_TRAINER_CARD_SCREEN);
param0->unk_1A0[0][2] = SpriteResourceCollection_AddFrom(param0->unk_190[2], param1, 44, 0, 1, 2, HEAP_ID_TRAINER_CARD_SCREEN);
param0->unk_1A0[0][3] = SpriteResourceCollection_AddFrom(param0->unk_190[3], param1, 46, 0, 1, 3, HEAP_ID_TRAINER_CARD_SCREEN);
SpriteTransfer_RequestChar(param0->unk_1A0[0][0]);
SpriteTransfer_RequestPlttWholeRange(param0->unk_1A0[0][1]);
{
u8 v1;
const int v2[8] = {
16, 17, 18, 19, 20, 21, 22, 23
};
for (v1 = 0; v1 < 8; v1++) {
param0->unk_224[v1] = NARC_AllocAndReadWholeMember(param1, v2[v1], 25);
if (param0->unk_224[v1] != NULL) {
if (NNS_G2dGetUnpackedPaletteData(param0->unk_224[v1], &param0->unk_244[v1]) == 0) {
Heap_Free(param0->unk_244[v1]);
GF_ASSERT(0);
}
} else {
GF_ASSERT(0);
}
}
}
GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, 1);
}
void ov71_0223D070(UnkStruct_ov71_0223D238 *param0, const u8 *param1)
{
int v0;
SpriteResourcesHeader v1;
SpriteResourcesHeader_Init(&v1, 1, 1, 1, 1, 0xffffffff, 0xffffffff, 0, 1, param0->unk_190[0], param0->unk_190[1], param0->unk_190[2], param0->unk_190[3], NULL, NULL);
{
u8 v2;
AffineSpriteListTemplate v3;
v3.list = param0->unk_00;
v3.resourceData = &v1;
v3.position.x = 0;
v3.position.y = 0;
v3.position.z = 0;
v3.affineScale.x = FX32_ONE;
v3.affineScale.y = FX32_ONE;
v3.affineScale.z = FX32_ONE;
v3.affineZRotation = 0;
v3.priority = 2;
v3.vramType = NNS_G2D_VRAM_TYPE_2DMAIN;
v3.heapID = HEAP_ID_TRAINER_CARD_SCREEN;
for (v0 = 0; v0 < 8; v0++) {
v3.position.x = FX32_ONE * Unk_ov71_0223D73C[v0].unk_00;
v3.position.y = FX32_ONE * Unk_ov71_0223D73C[v0].unk_04;
param0->unk_1C0[v0] = SpriteList_AddAffine(&v3);
Sprite_SetAnimateFlag(param0->unk_1C0[v0], 0);
Sprite_SetAnim(param0->unk_1C0[v0], v0);
if (!param1[v0]) {
Sprite_SetDrawFlag(param0->unk_1C0[v0], FALSE);
}
}
{
v2 = 8;
for (v0 = 0; v0 < 8; v0++) {
v3.position.x = FX32_ONE * Unk_ov71_0223D6FC[v0].unk_00;
v3.position.y = FX32_ONE * Unk_ov71_0223D6FC[v0].unk_04;
v3.priority = 1;
param0->unk_1C0[v2 + v0] = SpriteList_AddAffine(&v3);
Sprite_SetAnimateFlag(param0->unk_1C0[v2 + v0], 1);
Sprite_SetAnim(param0->unk_1C0[v2 + v0], 8);
Sprite_SetDrawFlag(param0->unk_1C0[v2 + v0], FALSE);
}
v2 += 8;
for (v0 = 0; v0 < 8; v0++) {
v3.position.x = FX32_ONE * Unk_ov71_0223D6FC[v0].unk_00;
v3.position.y = FX32_ONE * Unk_ov71_0223D6FC[v0].unk_04;
v3.priority = 1;
param0->unk_1C0[v2 + v0] = SpriteList_AddAffine(&v3);
Sprite_SetAnimateFlag(param0->unk_1C0[v2 + v0], 1);
Sprite_SetAnim(param0->unk_1C0[v2 + v0], 9);
Sprite_SetDrawFlag(param0->unk_1C0[v2 + v0], FALSE);
}
}
v2 += 8;
{
v1.priority = 0;
v3.position.x = FX32_ONE * (12 * 8);
v3.position.y = FX32_ONE * (17 * 8);
v3.priority = 0;
param0->unk_1C0[v2] = SpriteList_AddAffine(&v3);
Sprite_SetAnimateFlag(param0->unk_1C0[v2], 0);
Sprite_SetAnim(param0->unk_1C0[v2], 10);
Sprite_SetDrawFlag(param0->unk_1C0[v2], FALSE);
}
}
}
void ov71_0223D238(UnkStruct_ov71_0223D238 *param0)
{
u8 v0;
for (v0 = 0; v0 < 8; v0++) {
Heap_Free(param0->unk_224[v0]);
}
SpriteTransfer_ResetCharTransfer(param0->unk_1A0[0][0]);
SpriteTransfer_ResetPlttTransfer(param0->unk_1A0[0][1]);
for (v0 = 0; v0 < 4; v0++) {
SpriteResourceCollection_Delete(param0->unk_190[v0]);
}
SpriteList_Delete(param0->unk_00);
RenderOam_Free();
CharTransfer_Free();
PlttTransfer_Free();
}
void ov71_0223D298(UnkStruct_ov71_0223D238 *param0, const u8 param1, const u8 param2)
{
NNSG2dImagePaletteProxy *v0;
u32 v1;
u32 v2;
u8 *v3;
GF_ASSERT(param1 < 8);
GF_ASSERT(param2 <= 3);
v0 = Sprite_GetPaletteProxy(param0->unk_1C0[param1]);
v1 = NNS_G2dGetImagePaletteLocation(v0, NNS_G2D_VRAM_TYPE_2DMAIN);
v1 += param1 * (16 * 2);
v3 = param0->unk_244[param1]->pRawData;
DC_FlushRange(&v3[param2 * 16 * 2], 16 * 2);
GX_LoadOBJPltt(&v3[param2 * 16 * 2], v1, 16 * 2);
}
static void ov71_0223D2F4(void)
{
{
CharTransferTemplate v0 = {
1, 2048, 0, 25
};
CharTransfer_Init(&v0);
}
PlttTransfer_Init(2, HEAP_ID_TRAINER_CARD_SCREEN);
CharTransfer_ClearBuffers();
PlttTransfer_Clear();
}

156
src/overlay071/ov71_0223D324.c
View File

@ -1,156 +0,0 @@
#include "overlay071/ov71_0223D324.h"
#include <nitro.h>
#include <string.h>
#include "overlay071/struct_ov71_0223D324.h"
#include "sound.h"
static void ov71_0223D370(UnkStruct_ov71_0223D324 *param0);
static BOOL ov71_0223D3A0(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2);
static BOOL ov71_0223D3D8(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2);
static BOOL ov71_0223D410(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2);
static void ov71_0223D454(UnkStruct_ov71_0223D324 *param0);
static void ov71_0223D42C(UnkStruct_ov71_0223D324 *param0, int param1, int param2, int param3);
static void ov71_0223D470(int param0, const int param1, const u8 param2);
static const u16 Unk_ov71_0223D77C[8] = {
0x0,
0x80,
0x100,
0x140,
0x1C0,
0x240,
0x2C0,
0x300
};
void ov71_0223D324(UnkStruct_ov71_0223D324 *param0)
{
int v0, v1;
for (v0 = 0; v0 < 4; v0++) {
param0->unk_00[v0][0] = v0;
param0->unk_00[v0][1] = 0xff;
}
return;
}
void ov71_0223D338(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2)
{
int v0;
ov71_0223D370(param0);
if (ov71_0223D3A0(param0, param1, param2) == 1) {
return;
}
if (ov71_0223D3D8(param0, param1, param2) == 1) {
return;
}
if (ov71_0223D410(param0, param1, param2) == 1) {
return;
}
return;
}
static void ov71_0223D370(UnkStruct_ov71_0223D324 *param0)
{
int v0;
for (v0 = 0; v0 < 4; v0++) {
if (param0->unk_00[v0][1] != 0xff) {
if (Sound_GetNumberOfPlayingSequencesForPlayer(3 + param0->unk_00[v0][0]) == 0) {
param0->unk_00[v0][1] = 0xff;
}
}
}
ov71_0223D454(param0);
return;
}
static BOOL ov71_0223D3A0(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2)
{
int v0;
for (v0 = 0; v0 < 4; v0++) {
if (param0->unk_00[v0][1] == param1) {
ov71_0223D470(param0->unk_00[v0][0], param1, param2);
ov71_0223D42C(param0, v0, param0->unk_00[v0][0], param1);
return 1;
}
}
return 0;
}
static BOOL ov71_0223D3D8(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2)
{
int v0, v1;
for (v0 = 0; v0 < 4; v0++) {
if (param0->unk_00[v0][1] == 0xff) {
ov71_0223D470(param0->unk_00[v0][0], param1, param2);
ov71_0223D42C(param0, v0, param0->unk_00[v0][0], param1);
return 1;
}
}
return 0;
}
static BOOL ov71_0223D410(UnkStruct_ov71_0223D324 *param0, const int param1, const u8 param2)
{
int v0 = (4 - 1);
ov71_0223D470(param0->unk_00[v0][0], param1, param2);
ov71_0223D42C(param0, v0, param0->unk_00[v0][0], param1);
return 1;
}
static void ov71_0223D42C(UnkStruct_ov71_0223D324 *param0, int param1, int param2, int param3)
{
int v0;
for (v0 = param1; v0 > 0; v0--) {
param0->unk_00[v0][0] = param0->unk_00[v0 - 1][0];
param0->unk_00[v0][1] = param0->unk_00[v0 - 1][1];
}
param0->unk_00[0][0] = param2;
param0->unk_00[0][1] = param3;
return;
}
static void ov71_0223D454(UnkStruct_ov71_0223D324 *param0)
{
int v0;
for (v0 = 0; v0 < 4; v0++) {
if (param0->unk_00[v0][0] == 0xff) {
param0->unk_00[v0][0] = param0->unk_00[v0 + 1][0];
param0->unk_00[v0 + 1][0] = 0xff;
}
}
return;
}
static void ov71_0223D470(int param0, const int param1, const u8 param2)
{
int v0 = 152 * (4 - param2);
Sound_PlaySequenceWithPlayer((3 + param0), (3 + param0), 1684);
Sound_SetPitchForHandle((3 + param0), 0xffff, (Unk_ov71_0223D77C[param1] - v0));
return;
}

2
src/overlay084/ov84_0223B5A0.c
View File

@ -408,7 +408,7 @@ int ov84_0223B5A0(ApplicationManager *appMan, int *param1)
v0->unk_00 = BgConfig_New(HEAP_ID_6);
v0->unk_425 = TrainerInfo_Gender(v0->unk_CC);
StartScreenFade(FADE_MAIN_THEN_SUB, FADE_TYPE_UNK_3, FADE_TYPE_UNK_3, COLOR_BLACK, 6, 1, HEAP_ID_6);
StartScreenFade(FADE_MAIN_THEN_SUB, FADE_TYPE_DOWNWARD_IN, FADE_TYPE_DOWNWARD_IN, COLOR_BLACK, 6, 1, HEAP_ID_6);
SetAutorepeat(3, 8);
ov84_0223BEAC(v0);

4
src/overlay093/ov93_021D0D80.c
View File

@ -132,12 +132,12 @@ int ov93_021D0E70(ApplicationManager *appMan, int *param1)
0,
0,
0,
FX32_ONE
FX32_ONE,
};
VecFx32 v3 = {
FX32_ONE,
FX32_ONE,
FX32_ONE
FX32_ONE,
};
VecFx32 v4 = {
0,

4
src/overlay093/ov93_021D111C.c
View File

@ -133,12 +133,12 @@ int ov93_021D120C(ApplicationManager *appMan, int *param1)
0,
0,
0,
FX32_ONE
FX32_ONE,
};
VecFx32 v3 = {
FX32_ONE,
FX32_ONE,
FX32_ONE
FX32_ONE,
};
VecFx32 v4 = {
0,

4
src/overlay097/main_menu_util.c
View File

@ -442,8 +442,8 @@ Sprite *MainMenuUtil_InitSprite(enum DSScreen screen, Sprite *sprite, int x, int
template.affineScale.y = FX32_ONE;
template.affineScale.z = FX32_ONE;
template.affineZRotation = 0;
template.position.x = FX32_ONE *x;
template.position.y = FX32_ONE *y;
template.position.x = FX32_ONE * x;
template.position.y = FX32_ONE * y;
template.priority = 10;
template.vramType = screen == DS_SCREEN_MAIN ? NNS_G2D_VRAM_TYPE_2DMAIN : NNS_G2D_VRAM_TYPE_2DSUB;
template.heapID = utilMan->heapID;

2
src/overlay113/ov113_0225E368.c
View File

@ -242,7 +242,7 @@ static const struct {
-FX32_ONE * 16 * (5 + 0),
FX32_ONE * 16 * (5 + 0),
FX32_ONE * 16 * (3 + 0),
-FX32_ONE * 16 * (3 + 0)
-FX32_ONE * 16 * (3 + 0),
};
static const UnkStruct_ov113_02260CAC Unk_ov113_02260CAC[] = {

2
src/overlay117/ov117_02263AF0.c
View File

@ -296,7 +296,7 @@ static const fx32 Unk_ov117_02266BA4[] = {
FX32_ONE,
0x1800,
0xA00,
0x2000
0x2000,
};
static const u16 Unk_ov117_02266C54[][4] = {

6
src/pokemon.c
View File

@ -4213,7 +4213,7 @@ u8 Pokemon_HasPokerus(Party *party, u8 param1)
return result;
}
void Party_UpdatePokerusStatus(Party *party, s32 param1)
void Party_UpdatePokerusStatus(Party *party, s32 daysPassed)
{
int currentPartyCount = Party_GetCurrentCount(party);
@ -4224,10 +4224,10 @@ void Party_UpdatePokerusStatus(Party *party, s32 param1)
u8 monPokerus = Pokemon_GetValue(mon, MON_DATA_POKERUS, NULL);
if (monPokerus & 0xf) {
if (((monPokerus & 0xf) < param1) || (param1 > 4)) {
if (((monPokerus & 0xf) < daysPassed) || (daysPassed > 4)) {
monPokerus &= 0xf0;
} else {
monPokerus -= param1;
monPokerus -= daysPassed;
}
if (monPokerus == 0) {

4
src/screen_fade.c
View File

@ -81,8 +81,8 @@ static const ScreenFadeFunc sScreenFadeFuncs[FADE_TYPE_MAX] = {
[FADE_TYPE_BRIGHTNESS_OUT] = sub_0200F85C,
[FADE_TYPE_BRIGHTNESS_IN] = sub_0200F878,
[FADE_TYPE_UNK_2] = sub_0200F898,
[FADE_TYPE_UNK_3] = sub_0200F8D4,
[FADE_TYPE_UNK_4] = sub_0200F90C,
[FADE_TYPE_DOWNWARD_IN] = sub_0200F8D4,
[FADE_TYPE_UPWARD_OUT] = sub_0200F90C,
[FADE_TYPE_UNK_5] = sub_0200F948,
[FADE_TYPE_UNK_6] = sub_0200F980,
[FADE_TYPE_UNK_7] = sub_0200F9AC,

10
src/start_menu.c
View File

@ -1356,11 +1356,11 @@ static BOOL StartMenu_TrainerCard(FieldTask *taskMan)
menu->taskData = TrainerCard_New(HEAP_ID_FIELDMAP);
TrainerCard_Init(1, 1, 0, 0xff, fieldSystem, (TrainerCard *)menu->taskData);
sub_0203E09C(fieldSystem, (TrainerCard *)menu->taskData);
TrainerCard_Init(TRUE, TRUE, 0, 0xFF, fieldSystem, (TrainerCard *)menu->taskData);
FieldSystem_OpenTrainerCardScreen(fieldSystem, (TrainerCard *)menu->taskData);
menu->callback = sub_0203BF00;
return 0;
return FALSE;
}
static BOOL sub_0203BF00(FieldTask *taskMan)
@ -1368,13 +1368,13 @@ static BOOL sub_0203BF00(FieldTask *taskMan)
FieldSystem *fieldSystem = FieldTask_GetFieldSystem(taskMan);
StartMenu *menu = FieldTask_GetEnv(taskMan);
sub_020721D4(fieldSystem, (TrainerCard *)menu->taskData);
TrainerCard_SaveBadgePolish(fieldSystem, (TrainerCard *)menu->taskData);
TrainerCard_Free((TrainerCard *)menu->taskData);
FieldSystem_StartFieldMap(fieldSystem);
menu->state = START_MENU_STATE_12;
return 0;
return FALSE;
}
static BOOL StartMenu_SelectSave(FieldTask *taskMan)

2
src/system_vars.c
View File

@ -247,7 +247,7 @@ void SystemVars_RandomizeJubilifeLotteryTrainerID(VarsFlags *varsFlags)
#define LOTTERY_LCRNG_INCREMENT 12345
void SystemVars_SynchronizeJubilifeLotteryTrainerID(SaveData *saveData, u16 trainerID)
void SystemVars_SynchronizeJubilifeLotteryTrainerID(SaveData *saveData, u16 unused)
{
VarsFlags *varsFlags = SaveData_GetVarsFlags(saveData);
u32 recordMixedRand = RecordMixedRNG_GetRand(SaveData_GetRecordMixedRNG(saveData)) * LCRNG_MULTIPLIER + LOTTERY_LCRNG_INCREMENT;

87
src/trainer_card.c
View File

@ -10,6 +10,7 @@
#include "field/field_system.h"
#include "badges.h"
#include "charcode_util.h"
#include "field_system.h"
#include "field_task.h"
@ -29,27 +30,31 @@
#include "unk_0205B33C.h"
#include "vars_flags.h"
#define TRAINER_CARD_MAX_TIMES_LINKED 999999
#define TRAINER_CARD_MAX_LINK_BATTLE_RESULTS 9999
#define TRAINER_CARD_MAX_LINK_TRADES 99999
typedef struct {
int unk_00;
TrainerCard *unk_04;
} UnkStruct_02072204;
static void sub_02072014(u8 param0, u8 gameVersion, u8 stars, u8 param3, u8 regionCode, TrainerCard *trainerCard);
static void TrainerCard_SetFields(u8 badgesInteractable, u8 gameVersion, u8 stars, u8 gymLeadersToHide, u8 regionCode, TrainerCard *trainerCard);
static void TrainerCard_SetTrainerInfo(u16 id, u8 gender, const u16 *name, u32 money, u32 seenPokemon, BOOL pokedexObtained, u32 score, TrainerCard *trainerCard);
static void TrainerCard_SetDates(u8 gameCompleted, const PlayTime *playTime, const RTCDate *adventureStartedDate, const RTCDate *hofDebutDate, const RTCTime *hofDebutTime, u8 param5, TrainerCard *trainerCard);
static void TrainerCard_SetLinkDataAndSignature(u32 param0, u32 param1, u32 param2, u32 param3, const u8 *param4, TrainerCard *trainerCard);
static void sub_0207216C(TrainerInfo *param0, FieldSystem *fieldSystem, TrainerCard *trainerCard);
static void TrainerCard_SetLinkDataAndSignature(u32 timesLinked, u32 linkBattleWins, u32 linkBattleLosses, u32 linkTrades, const u8 *signature, TrainerCard *trainerCard);
static void TrainerCard_SetBadgeData(TrainerInfo *trainerInfo, FieldSystem *fieldSystem, TrainerCard *trainerCard);
static BOOL sub_02072230(FieldTask *param0);
void TrainerCard_Init(u8 param0, u8 param1, u8 param2, u8 param3, FieldSystem *fieldSystem, TrainerCard *trainerCard)
void TrainerCard_Init(u8 badgesInteractable, u8 liveTimeDisplay, u8 gymLeadersToHide, u8 trainerAppearance, FieldSystem *fieldSystem, TrainerCard *trainerCard)
{
SaveData *saveData = FieldSystem_GetSaveData(fieldSystem);
TrainerInfo *trainerInfo = SaveData_GetTrainerInfo(saveData);
GameRecords *gameRecords = SaveData_GetGameRecords(saveData);
trainerCard->unk_05 = param3;
trainerCard->trainerAppearance = trainerAppearance;
sub_02072014(param0, GAME_VERSION, TrainerCard_CalculateStars(fieldSystem), param2, TrainerInfo_RegionCode(trainerInfo), trainerCard);
TrainerCard_SetFields(badgesInteractable, GAME_VERSION, TrainerCard_CalculateStars(fieldSystem), gymLeadersToHide, TrainerInfo_RegionCode(trainerInfo), trainerCard);
TrainerCard_SetTrainerInfo(TrainerInfo_ID_LowHalf(trainerInfo), TrainerInfo_Gender(trainerInfo), TrainerInfo_Name(trainerInfo), TrainerInfo_Money(trainerInfo), Pokedex_CountSeen(SaveData_GetPokedex(fieldSystem->saveData)), Pokedex_IsObtained(SaveData_GetPokedex(fieldSystem->saveData)), GameRecords_GetTrainerScore(gameRecords), trainerCard);
@ -60,7 +65,7 @@ void TrainerCard_Init(u8 param0, u8 param1, u8 param2, u8 param3, FieldSystem *f
FieldSystem_GetStartTimestamp(fieldSystem, &adventureStartedDate, &firstCompletionTime);
FieldSystem_GetFirstCompletionTimestamp(fieldSystem, &firstCompletionDate, &firstCompletionTime);
TrainerCard_SetDates(SystemFlag_CheckGameCompleted(SaveData_GetVarsFlags(fieldSystem->saveData)), playTime, &adventureStartedDate, &firstCompletionDate, &firstCompletionTime, param1, trainerCard);
TrainerCard_SetDates(SystemFlag_CheckGameCompleted(SaveData_GetVarsFlags(fieldSystem->saveData)), playTime, &adventureStartedDate, &firstCompletionDate, &firstCompletionTime, liveTimeDisplay, trainerCard);
TrainerCardSaveData *tcSaveData = SaveData_GetTrainerCardSaveData(fieldSystem->saveData);
u32 timesLinked = GameRecords_GetRecordValue(gameRecords, RECORD_UNK_091) + GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_020) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_025) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_032);
@ -70,13 +75,13 @@ void TrainerCard_Init(u8 param0, u8 param1, u8 param2, u8 param3, FieldSystem *f
TrainerCard_SetLinkDataAndSignature(timesLinked, linkBattleWins, linkBattleLosses, linkTrades, TrainerCardSaveData_GetSignature(tcSaveData), trainerCard);
sub_0207216C(trainerInfo, fieldSystem, trainerCard);
TrainerCard_SetBadgeData(trainerInfo, fieldSystem, trainerCard);
int i, checksum = 0;
u8 *v15 = (u8 *)trainerCard;
u8 *buffer = (u8 *)trainerCard;
for (i = 0; i < sizeof(TrainerCard); i++) {
checksum ^= v15[i];
checksum ^= buffer[i];
}
trainerCard->checksum = checksum;
@ -131,13 +136,13 @@ u8 TrainerCard_CalculateStars(FieldSystem *fieldSystem)
return trainerCardStars;
}
static void sub_02072014(u8 param0, u8 gameVersion, u8 stars, u8 param3, u8 regionCode, TrainerCard *trainerCard)
static void TrainerCard_SetFields(u8 badgesInteractable, u8 gameVersion, u8 stars, u8 gymLeadersToHide, u8 regionCode, TrainerCard *trainerCard)
{
trainerCard->unk_04_0 = param0;
trainerCard->badgesInteractable = badgesInteractable;
trainerCard->gameVersion = gameVersion;
trainerCard->stars = stars;
trainerCard->regionCode = regionCode;
trainerCard->unk_02 = param3;
trainerCard->gymLeadersToHide_Unused = gymLeadersToHide;
}
static void TrainerCard_SetTrainerInfo(u16 id, u8 gender, const u16 *name, u32 money, u32 seenPokemon, BOOL pokedexObtained, u32 score, TrainerCard *trainerCard)
@ -153,7 +158,7 @@ static void TrainerCard_SetTrainerInfo(u16 id, u8 gender, const u16 *name, u32 m
trainerCard->score = score;
}
static void TrainerCard_SetDates(u8 gameCompleted, const PlayTime *playTime, const RTCDate *adventureStartedDate, const RTCDate *firstCompletionDate, const RTCTime *firstCompletionTime, const u8 param5, TrainerCard *trainerCard)
static void TrainerCard_SetDates(u8 gameCompleted, const PlayTime *playTime, const RTCDate *adventureStartedDate, const RTCDate *firstCompletionDate, const RTCTime *firstCompletionTime, const u8 liveTimeDisplay, TrainerCard *trainerCard)
{
trainerCard->playTimeHours = PlayTime_GetHours(playTime);
trainerCard->playTimeMinutes = PlayTime_GetMinutes(playTime);
@ -175,9 +180,9 @@ static void TrainerCard_SetDates(u8 gameCompleted, const PlayTime *playTime, con
trainerCard->hofDebutMinute = 0;
}
trainerCard->unk_04_1 = param5;
trainerCard->liveTimeDisplay = liveTimeDisplay;
if (param5) {
if (liveTimeDisplay) {
trainerCard->playTime = playTime;
} else {
trainerCard->playTime = NULL;
@ -188,55 +193,55 @@ static void TrainerCard_SetLinkDataAndSignature(u32 timesLinked, u32 linkBattleW
{
trainerCard->timesLinked = timesLinked;
if (trainerCard->timesLinked > 999999) {
trainerCard->timesLinked = 999999;
if (trainerCard->timesLinked > TRAINER_CARD_MAX_TIMES_LINKED) {
trainerCard->timesLinked = TRAINER_CARD_MAX_TIMES_LINKED;
}
trainerCard->linkBattleWins = linkBattleWins;
trainerCard->linkBattleLosses = linkBattleLosses;
if (trainerCard->linkBattleWins > 9999) {
trainerCard->linkBattleWins = 9999;
if (trainerCard->linkBattleWins > TRAINER_CARD_MAX_LINK_BATTLE_RESULTS) {
trainerCard->linkBattleWins = TRAINER_CARD_MAX_LINK_BATTLE_RESULTS;
}
if (trainerCard->linkBattleLosses > 9999) {
trainerCard->linkBattleLosses = 9999;
if (trainerCard->linkBattleLosses > TRAINER_CARD_MAX_LINK_BATTLE_RESULTS) {
trainerCard->linkBattleLosses = TRAINER_CARD_MAX_LINK_BATTLE_RESULTS;
}
trainerCard->linkTrades = linkTrades;
if (trainerCard->linkTrades > 99999) {
trainerCard->linkTrades = 99999;
if (trainerCard->linkTrades > TRAINER_CARD_MAX_LINK_TRADES) {
trainerCard->linkTrades = TRAINER_CARD_MAX_LINK_TRADES;
}
MI_CpuCopy8(signature, trainerCard->signature, 24 * 8 * 8);
MI_CpuCopy8(signature, trainerCard->signature, SIGNATURE_WIDTH * SIGNATURE_HEIGHT * 8);
}
static void sub_0207216C(TrainerInfo *param0, FieldSystem *fieldSystem, TrainerCard *trainerCard)
static void TrainerCard_SetBadgeData(TrainerInfo *trainerInfo, FieldSystem *fieldSystem, TrainerCard *trainerCard)
{
u8 v0;
TrainerCardSaveData *v1 = SaveData_GetTrainerCardSaveData(fieldSystem->saveData);
TrainerCardBadge *v2 = TrainerCardSaveData_GetTrainerCardBadges(v1);
u8 badgeID;
TrainerCardSaveData *tcSaveData = SaveData_GetTrainerCardSaveData(fieldSystem->saveData);
TrainerCardSaveDataBadge *badges = TrainerCardSaveData_GetTrainerCardSaveDataBadges(tcSaveData);
for (v0 = 0; v0 < 8; v0++) {
if (TrainerInfo_HasBadge(param0, v0)) {
trainerCard->unk_48[v0].unk_00_0 = 1;
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
if (TrainerInfo_HasBadge(trainerInfo, badgeID)) {
trainerCard->badges[badgeID].obtained = TRUE;
} else {
trainerCard->unk_48[v0].unk_00_0 = 0;
trainerCard->badges[badgeID].obtained = FALSE;
}
trainerCard->unk_48[v0].unk_00_1 = TrainerCardBadge_GetCleanliness(v0, v2);
trainerCard->badges[badgeID].polish = TrainerCardSaveDataBadge_GetPolish(badgeID, badges);
}
}
void sub_020721D4(FieldSystem *fieldSystem, const TrainerCard *trainerCard)
void TrainerCard_SaveBadgePolish(FieldSystem *fieldSystem, const TrainerCard *trainerCard)
{
u8 v0;
TrainerCardSaveData *v1 = SaveData_GetTrainerCardSaveData(fieldSystem->saveData);
TrainerCardBadge *v2 = TrainerCardSaveData_GetTrainerCardBadges(v1);
u8 badgeID;
TrainerCardSaveData *tcSaveData = SaveData_GetTrainerCardSaveData(fieldSystem->saveData);
TrainerCardSaveDataBadge *badges = TrainerCardSaveData_GetTrainerCardSaveDataBadges(tcSaveData);
for (v0 = 0; v0 < 8; v0++) {
TrainerCardBadge_SetCleanliness(v0, trainerCard->unk_48[v0].unk_00_1, v2);
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
TrainerCardSaveDataBadge_SetPolish(badgeID, trainerCard->badges[badgeID].polish, badges);
}
}
@ -265,7 +270,7 @@ static BOOL sub_02072230(FieldTask *param0)
}
break;
case 10:
sub_0203E09C(fieldSystem, v1->unk_04);
FieldSystem_OpenTrainerCardScreen(fieldSystem, v1->unk_04);
v1->unk_00 = 11;
break;
case 11:

43
src/trainer_card_badge_dirt.c Normal file
View File

@ -0,0 +1,43 @@
#include "trainer_card_badge_dirt.h"
#include <nitro.h>
#include <string.h>
#include "badges.h"
#include "save_player.h"
#include "savedata.h"
#include "trainer_card.h"
#include "trainer_card_save_data.h"
#include "trainer_info.h"
void TrainerCard_AccumulateBadgeDirt(SaveData *saveData, s32 daysPassed)
{
if (daysPassed <= 0) {
return;
}
TrainerCardSaveData *tcSaveData = SaveData_GetTrainerCardSaveData(saveData);
TrainerCardSaveDataBadge *badges = TrainerCardSaveData_GetTrainerCardSaveDataBadges(tcSaveData);
TrainerInfo *trainerInfo = SaveData_GetTrainerInfo(saveData);
for (u8 badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
if (TrainerInfo_HasBadge(trainerInfo, badgeID) == 0) {
continue;
}
int polish = TrainerCardSaveDataBadge_GetPolish(badgeID, badges);
if (0 < polish && polish < MAX_BADGE_POLISH + 1) {
polish -= (10 * daysPassed);
} else {
GF_ASSERT(polish < MAX_BADGE_POLISH + 1);
polish = 0;
}
if (polish < 0) {
polish = 0;
}
TrainerCardSaveDataBadge_SetPolish(badgeID, polish, badges);
}
}

16
src/trainer_card_save_data.c
View File

@ -15,12 +15,12 @@ void TrainerCardSaveData_Init(TrainerCardSaveData *tcSaveData)
memset(tcSaveData, 0, sizeof(TrainerCardSaveData));
int badgeID;
TrainerCardBadge *badges;
TrainerCardSaveDataBadge *badges;
badges = TrainerCardSaveData_GetTrainerCardBadges(tcSaveData);
badges = TrainerCardSaveData_GetTrainerCardSaveDataBadges(tcSaveData);
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
TrainerCardBadge_SetCleanliness(badgeID, 140, badges);
TrainerCardSaveDataBadge_SetPolish(badgeID, BADGE_POLISH_THRESHOLD_NORMAL, badges);
}
}
@ -34,17 +34,17 @@ u8 *TrainerCardSaveData_GetSignature(TrainerCardSaveData *tcSaveData)
return tcSaveData->signature;
}
TrainerCardBadge *TrainerCardSaveData_GetTrainerCardBadges(TrainerCardSaveData *tcSaveData)
TrainerCardSaveDataBadge *TrainerCardSaveData_GetTrainerCardSaveDataBadges(TrainerCardSaveData *tcSaveData)
{
return tcSaveData->badges;
}
int TrainerCardBadge_GetCleanliness(const u8 badgeID, TrainerCardBadge *badges)
int TrainerCardSaveDataBadge_GetPolish(u8 badgeID, TrainerCardSaveDataBadge *badges)
{
return badges[badgeID].cleanliness;
return badges[badgeID].polish;
}
void TrainerCardBadge_SetCleanliness(const u8 badgeID, const int cleanliness, TrainerCardBadge *badges)
void TrainerCardSaveDataBadge_SetPolish(u8 badgeID, int polish, TrainerCardSaveDataBadge *badges)
{
badges[badgeID].cleanliness = cleanliness;
badges[badgeID].polish = polish;
}

139
src/trainer_card_screen/trainer_card_badge_chimes.c Normal file
View File

@ -0,0 +1,139 @@
#include "trainer_card_screen/trainer_card_badge_chimes.h"
#include <nitro.h>
#include <string.h>
#include "trainer_card_screen/trainer_card_screen.h"
#include "trainer_card_screen/trainer_card_screen_defs.h"
#include "badges.h"
#include "sound.h"
#define SFX_PLAYER_INDEX 0
#define ACTIVE_BADGE_CHIME 1
#define NO_BADGE_CHIME 0xFF
static void TrainerCard_CheckBadgeChimesFinishedPlaying(TrainerCardBadgeChimeState *badgeChimeState);
static BOOL TrainerCard_FindSoundEffectPlayerWithSameBadgeChime(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel);
static BOOL TrainerCard_FindFreeSoundEffectPlayer(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel);
static BOOL TrainerCard_GetLeastRecentlyUsedSoundEffectPlayer(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel);
static void TrainerCard_DoNothing(TrainerCardBadgeChimeState *badgeChimeState);
static void TrainerCard_FlagSoundEffectPlayerAsInUse(TrainerCardBadgeChimeState *badgeChimeState, int index, int sfxPlayerIndex, int badgeID);
static void TrainerCard_PlayBadgeChimeSoundEffect(int badgeChimeState, int badgeID, u8 polishLevel);
static const u16 sBadgeChimeBasePitches[MAX_BADGES] = {
[BADGE_ID_COAL] = 0,
[BADGE_ID_FOREST] = 128,
[BADGE_ID_COBBLE] = 256,
[BADGE_ID_FEN] = 320,
[BADGE_ID_RELIC] = 448,
[BADGE_ID_MINE] = 576,
[BADGE_ID_ICICLE] = 704,
[BADGE_ID_BEACON] = 768
};
void TrainerCard_InitBadgeChimeState(TrainerCardBadgeChimeState *badgeChimeState)
{
for (int i = 0; i < NUM_SE_PLAYERS; i++) {
badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX] = i;
badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] = NO_BADGE_CHIME;
}
}
void TrainerCard_PlayBadgeChime(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel)
{
TrainerCard_CheckBadgeChimesFinishedPlaying(badgeChimeState);
if (TrainerCard_FindSoundEffectPlayerWithSameBadgeChime(badgeChimeState, badgeID, polishLevel) == TRUE) {
return;
}
if (TrainerCard_FindFreeSoundEffectPlayer(badgeChimeState, badgeID, polishLevel) == TRUE) {
return;
}
if (TrainerCard_GetLeastRecentlyUsedSoundEffectPlayer(badgeChimeState, badgeID, polishLevel) == TRUE) {
return;
}
}
static void TrainerCard_CheckBadgeChimesFinishedPlaying(TrainerCardBadgeChimeState *badgeChimeState)
{
for (int i = 0; i < NUM_SE_PLAYERS; i++) {
if (badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] != NO_BADGE_CHIME) {
if (Sound_GetNumberOfPlayingSequencesForPlayer(PLAYER_SE_1 + badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX]) == 0) {
badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] = NO_BADGE_CHIME;
}
}
}
TrainerCard_DoNothing(badgeChimeState);
}
static BOOL TrainerCard_FindSoundEffectPlayerWithSameBadgeChime(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel)
{
for (int i = 0; i < NUM_SE_PLAYERS; i++) {
if (badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] == badgeID) {
TrainerCard_PlayBadgeChimeSoundEffect(badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX], badgeID, polishLevel);
TrainerCard_FlagSoundEffectPlayerAsInUse(badgeChimeState, i, badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX], badgeID);
return TRUE;
}
}
return FALSE;
}
static BOOL TrainerCard_FindFreeSoundEffectPlayer(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel)
{
for (int i = 0; i < NUM_SE_PLAYERS; i++) {
if (badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] == NO_BADGE_CHIME) {
TrainerCard_PlayBadgeChimeSoundEffect(badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX], badgeID, polishLevel);
TrainerCard_FlagSoundEffectPlayerAsInUse(badgeChimeState, i, badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX], badgeID);
return TRUE;
}
}
return FALSE;
}
static BOOL TrainerCard_GetLeastRecentlyUsedSoundEffectPlayer(TrainerCardBadgeChimeState *badgeChimeState, int badgeID, u8 polishLevel)
{
int index = NUM_SE_PLAYERS - 1;
TrainerCard_PlayBadgeChimeSoundEffect(badgeChimeState->badgeChimePlayers[index][SFX_PLAYER_INDEX], badgeID, polishLevel);
TrainerCard_FlagSoundEffectPlayerAsInUse(badgeChimeState, index, badgeChimeState->badgeChimePlayers[index][SFX_PLAYER_INDEX], badgeID);
return TRUE;
}
static void TrainerCard_FlagSoundEffectPlayerAsInUse(TrainerCardBadgeChimeState *badgeChimeState, int index, int sfxPlayerIndex, int badgeID)
{
for (int i = index; i > 0; i--) {
badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX] = badgeChimeState->badgeChimePlayers[i - 1][SFX_PLAYER_INDEX];
badgeChimeState->badgeChimePlayers[i][ACTIVE_BADGE_CHIME] = badgeChimeState->badgeChimePlayers[i - 1][ACTIVE_BADGE_CHIME];
}
badgeChimeState->badgeChimePlayers[0][SFX_PLAYER_INDEX] = sfxPlayerIndex;
badgeChimeState->badgeChimePlayers[0][ACTIVE_BADGE_CHIME] = badgeID;
}
static void TrainerCard_DoNothing(TrainerCardBadgeChimeState *badgeChimeState)
{
for (int i = 0; i < NUM_SE_PLAYERS; i++) {
if (badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX] == NO_BADGE_CHIME) {
// bug: this function uses the wrong index and therefore the above condition is never met
// good thing too because there's an out of bounds array access in here
badgeChimeState->badgeChimePlayers[i][SFX_PLAYER_INDEX] = badgeChimeState->badgeChimePlayers[i + 1][SFX_PLAYER_INDEX];
badgeChimeState->badgeChimePlayers[i + 1][SFX_PLAYER_INDEX] = NO_BADGE_CHIME;
}
}
}
static void TrainerCard_PlayBadgeChimeSoundEffect(int sfxPlayerIndex, int badgeID, u8 polishLevel)
{
int pitchModifier = 152 * (BADGE_POLISH_LEVEL_4_SPARKLES - polishLevel);
Sound_PlaySequenceWithPlayer(SOUND_HANDLE_TYPE_SFX_1 + sfxPlayerIndex, PLAYER_SE_1 + sfxPlayerIndex, SEQ_SE_DP_BADGE_C);
Sound_SetPitchForHandle(SOUND_HANDLE_TYPE_SFX_1 + sfxPlayerIndex, SOUND_PLAYBACK_TRACK_ALL, sBadgeChimeBasePitches[badgeID] - pitchModifier);
}

36
src/overlay071/trainer_card_display_text.c → src/trainer_card_screen/trainer_card_display_text.c
View File

@ -1,11 +1,11 @@
#include "overlay071/trainer_card_display_text.h"
#include "trainer_card_screen/trainer_card_display_text.h"
#include <nitro.h>
#include <string.h>
#include "constants/heap.h"
#include "overlay071/struct_ov71_0223B620.h"
#include "trainer_card_screen/trainer_card_screen_defs.h"
#include "bg_window.h"
#include "font.h"
@ -22,8 +22,8 @@
#define TRAINER_CARD_WINDOW_FULL_WIDTH 28
#define TRAINER_CARD_WINDOW_HEIGHT 2
static void TrainerCard_DrawNumber(Window *window, const u32 windowWidth, const u32 endXOffset, const u32 yOffset, Strbuf *strbuf, const u32 num, const u8 maxDigits, enum PaddingMode paddingMode);
static void TrainerCard_DrawString(Window *window, const u32 windowWidth, const u32 endXOffset, const u32 yOffset, const Strbuf *strbuf);
static void TrainerCard_DrawNumber(Window *window, u32 windowWidth, u32 endXOffset, u32 yOffset, Strbuf *strbuf, u32 num, u8 maxDigits, enum PaddingMode paddingMode);
static void TrainerCard_DrawString(Window *window, u32 windowWidth, u32 endXOffset, u32 yOffset, const Strbuf *strbuf);
static const WindowTemplate sTrainerCardWindowTemplates[] = {
[TRAINER_CARD_WINDOW_ID] = {
@ -211,7 +211,7 @@ void TrainerCard_DrawFrontText(Window *windows, const TrainerCard *trainerCard)
TrainerCard_DrawNumber(&windows[TRAINER_CARD_WINDOW_SCORE], TRAINER_CARD_WINDOW_PARTIAL_WIDTH * TILE_WIDTH_PIXELS, 0, 0, strbuf, trainerCard->score, 9, PADDING_MODE_SPACES);
if (trainerCard->unk_04_1) {
if (trainerCard->liveTimeDisplay) {
StringTemplate_SetNumber(template, 0, PlayTime_GetHours(trainerCard->playTime), 3, PADDING_MODE_SPACES, CHARSET_MODE_EN);
StringTemplate_SetNumber(template, 1, PlayTime_GetMinutes(trainerCard->playTime), 2, PADDING_MODE_ZEROES, CHARSET_MODE_EN);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_Format_HHMMWithoutColon, fmtString);
@ -277,17 +277,17 @@ void TrainerCard_DrawBackText(Window *windows, const TrainerCard *trainerCard)
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_BlankDate, strbuf);
}
u32 xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(0, strbuf, 0);
u32 xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(&windows[TRAINER_CARD_WINDOW_HOF_DEBUT], FONT_SYSTEM, strbuf, xOffset, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_Format_HHMMWithColon, fmtString);
StringTemplate_Format(template, strbuf, fmtString);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(0, strbuf, 0);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(&windows[TRAINER_CARD_WINDOW_HOF_DEBUT], FONT_SYSTEM, strbuf, xOffset, 16, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
StringTemplate_SetNumber(template, 5, trainerCard->timesLinked, 6, PADDING_MODE_NONE, CHARSET_MODE_EN);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_Format_Number_2, fmtString);
StringTemplate_Format(template, strbuf, fmtString);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(0, strbuf, 0);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(&windows[TRAINER_CARD_WINDOW_TIMES_LINKED], FONT_SYSTEM, strbuf, xOffset, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_W, strbuf);
@ -300,8 +300,8 @@ void TrainerCard_DrawBackText(Window *windows, const TrainerCard *trainerCard)
StringTemplate_SetNumber(template, 5, trainerCard->linkTrades, 6, PADDING_MODE_NONE, CHARSET_MODE_EN);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_Format_Number_2, fmtString);
StringTemplate_Format(template, strbuf, fmtString);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(0, strbuf, 0);
Text_AddPrinterWithParamsAndColor(&windows[TRAINER_CARD_WINDOW_LINK_TRADES], FONT_SYSTEM, strbuf, xOffset, 0, 0, TEXT_COLOR(1, 2, 0), NULL);
xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(&windows[TRAINER_CARD_WINDOW_LINK_TRADES], FONT_SYSTEM, strbuf, xOffset, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
Strbuf_Free(fmtString);
StringTemplate_Free(template);
@ -309,23 +309,21 @@ void TrainerCard_DrawBackText(Window *windows, const TrainerCard *trainerCard)
MessageLoader_Free(messageLoader);
}
void TrainerCard_ClearWindows(Window *windows, const u8 start, const u8 end)
void TrainerCard_ClearWindows(Window *windows, u8 start, u8 end)
{
u8 i;
for (i = start; i <= end; i++) {
for (u8 i = start; i <= end; i++) {
Window_ClearAndCopyToVRAM(&windows[i]);
}
}
static void TrainerCard_DrawNumber(Window *window, const u32 windowWidth, const u32 endXOffset, const u32 yOffset, Strbuf *strbuf, const u32 num, const u8 maxDigits, enum PaddingMode paddingMode)
static void TrainerCard_DrawNumber(Window *window, u32 windowWidth, u32 endXOffset, u32 yOffset, Strbuf *strbuf, u32 num, u8 maxDigits, enum PaddingMode paddingMode)
{
Strbuf_FormatInt(strbuf, num, maxDigits, paddingMode, CHARSET_MODE_EN);
u32 width = Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(window, FONT_SYSTEM, strbuf, windowWidth - (width + endXOffset), yOffset, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
}
static void TrainerCard_DrawString(Window *window, const u32 windowWidth, const u32 endXOffset, const u32 yOffset, const Strbuf *strbuf)
static void TrainerCard_DrawString(Window *window, u32 windowWidth, u32 endXOffset, u32 yOffset, const Strbuf *strbuf)
{
u32 width = Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
Text_AddPrinterWithParamsAndColor(window, FONT_SYSTEM, strbuf, windowWidth - (width + endXOffset), yOffset, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);
@ -348,8 +346,8 @@ void TrainerCard_DrawUpdatedTime(Window *windows, const TrainerCard *trainerCard
Strbuf *fmtString = Strbuf_Init(32, HEAP_ID_TRAINER_CARD_SCREEN);
StringTemplate *template = StringTemplate_New(2, 32, HEAP_ID_TRAINER_CARD_SCREEN);
StringTemplate_SetNumber(template, 0, PlayTime_GetHours(trainerCard->playTime), 3, 1, 1);
StringTemplate_SetNumber(template, 1, PlayTime_GetMinutes(trainerCard->playTime), 2, 2, 1);
StringTemplate_SetNumber(template, 0, PlayTime_GetHours(trainerCard->playTime), 3, PADDING_MODE_SPACES, CHARSET_MODE_EN);
StringTemplate_SetNumber(template, 1, PlayTime_GetMinutes(trainerCard->playTime), 2, PADDING_MODE_ZEROES, CHARSET_MODE_EN);
MessageLoader_GetStrbuf(messageLoader, TrainerCard_Text_Format_HHMMWithoutColon, fmtString);
StringTemplate_Format(template, strbuf, fmtString);
u32 xOffset = TRAINER_CARD_WINDOW_FULL_WIDTH * TILE_WIDTH_PIXELS - Font_CalcStrbufWidth(FONT_SYSTEM, strbuf, 0);
@ -361,7 +359,7 @@ void TrainerCard_DrawUpdatedTime(Window *windows, const TrainerCard *trainerCard
StringTemplate_Free(template);
}
void TrainerCard_BlinkPlaytimeColon(Window *window, const BOOL showColon, Strbuf *strbuf)
void TrainerCard_BlinkPlaytimeColon(Window *window, BOOL showColon, Strbuf *strbuf)
{
if (showColon) {
Text_AddPrinterWithParamsAndColor(window, FONT_SYSTEM, strbuf, 205, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL);

1323
src/trainer_card_screen/trainer_card_screen.c Normal file
View File

File diff suppressed because it is too large Load Diff

226
src/trainer_card_screen/trainer_card_sprites.c Normal file
View File

@ -0,0 +1,226 @@
#include "trainer_card_screen/trainer_card_sprites.h"
#include <nitro.h>
#include <string.h>
#include "trainer_card_screen/trainer_card_screen_defs.h"
#include "badges.h"
#include "char_transfer.h"
#include "gx_layers.h"
#include "heap.h"
#include "narc.h"
#include "pltt_transfer.h"
#include "render_oam.h"
#include "sprite.h"
#include "sprite_resource.h"
#include "sprite_transfer.h"
#include "sprite_util.h"
typedef struct Coordinates {
int x;
int y;
} Coordinates;
static const u8 sSpriteResourceCapacities[4] = {
[SPRITE_RESOURCE_CHAR] = 1,
[SPRITE_RESOURCE_PLTT] = 2,
[SPRITE_RESOURCE_CELL] = 1,
[SPRITE_RESOURCE_ANIM] = 1
};
static const Coordinates sBadgeCoordinates[] = {
[BADGE_ID_COAL] = { .x = 24, .y = 40 },
[BADGE_ID_FOREST] = { .x = 80, .y = 40 },
[BADGE_ID_COBBLE] = { .x = 136, .y = 40 },
[BADGE_ID_FEN] = { .x = 192, .y = 40 },
[BADGE_ID_RELIC] = { .x = 24, .y = 72 },
[BADGE_ID_MINE] = { .x = 80, .y = 72 },
[BADGE_ID_ICICLE] = { .x = 136, .y = 72 },
[BADGE_ID_BEACON] = { .x = 192, .y = 72 }
};
static const Coordinates sSparkleCoordinates[] = {
[BADGE_ID_COAL] = { .x = 24, .y = 40 },
[BADGE_ID_FOREST] = { .x = 80, .y = 40 },
[BADGE_ID_COBBLE] = { .x = 136, .y = 40 },
[BADGE_ID_FEN] = { .x = 192, .y = 40 },
[BADGE_ID_RELIC] = { .x = 24, .y = 96 },
[BADGE_ID_MINE] = { .x = 80, .y = 96 },
[BADGE_ID_ICICLE] = { .x = 136, .y = 96 },
[BADGE_ID_BEACON] = { .x = 192, .y = 96 }
};
static void TrainerCard_InitCharPlttTransferBuffers(void);
void TrainerCard_InitSpriteData(TrainerCardSpriteData *spriteData, NARC *narc)
{
int resourceType;
TrainerCard_InitCharPlttTransferBuffers();
NNS_G2dInitOamManagerModule();
RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, HEAP_ID_TRAINER_CARD_SCREEN);
spriteData->spriteList = SpriteList_InitRendering((MAX_BADGES * 3 + 1), &spriteData->g2dRenderer, HEAP_ID_TRAINER_CARD_SCREEN);
for (resourceType = SPRITE_RESOURCE_CHAR; resourceType < SPRITE_RESOURCE_MULTI_CELL; resourceType++) {
spriteData->spriteResourceCollection[resourceType] = SpriteResourceCollection_New(sSpriteResourceCapacities[resourceType], resourceType, HEAP_ID_TRAINER_CARD_SCREEN);
}
spriteData->spriteResources[0][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTilesFrom(spriteData->spriteResourceCollection[SPRITE_RESOURCE_CHAR], narc, 33, FALSE, 1, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_TRAINER_CARD_SCREEN);
spriteData->spriteResources[0][SPRITE_RESOURCE_PLTT] = SpriteResourceCollection_AddPaletteFrom(spriteData->spriteResourceCollection[SPRITE_RESOURCE_PLTT], narc, 14, FALSE, 1, NNS_G2D_VRAM_TYPE_2DMAIN, 9, HEAP_ID_TRAINER_CARD_SCREEN);
spriteData->spriteResources[0][SPRITE_RESOURCE_CELL] = SpriteResourceCollection_AddFrom(spriteData->spriteResourceCollection[SPRITE_RESOURCE_CELL], narc, 44, FALSE, 1, SPRITE_RESOURCE_CELL, HEAP_ID_TRAINER_CARD_SCREEN);
spriteData->spriteResources[0][SPRITE_RESOURCE_ANIM] = SpriteResourceCollection_AddFrom(spriteData->spriteResourceCollection[SPRITE_RESOURCE_ANIM], narc, 46, FALSE, 1, SPRITE_RESOURCE_ANIM, HEAP_ID_TRAINER_CARD_SCREEN);
SpriteTransfer_RequestChar(spriteData->spriteResources[0][SPRITE_RESOURCE_CHAR]);
SpriteTransfer_RequestPlttWholeRange(spriteData->spriteResources[0][SPRITE_RESOURCE_PLTT]);
u8 badgeID;
const int badgePaletteNarcIndices[MAX_BADGES] = {
[BADGE_ID_COAL] = 16,
[BADGE_ID_FOREST] = 17,
[BADGE_ID_COBBLE] = 18,
[BADGE_ID_FEN] = 19,
[BADGE_ID_RELIC] = 20,
[BADGE_ID_MINE] = 21,
[BADGE_ID_ICICLE] = 22,
[BADGE_ID_BEACON] = 23
};
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
spriteData->badgePaletteBuffers[badgeID] = NARC_AllocAndReadWholeMember(narc, badgePaletteNarcIndices[badgeID], HEAP_ID_TRAINER_CARD_SCREEN);
if (spriteData->badgePaletteBuffers[badgeID] != NULL) {
if (NNS_G2dGetUnpackedPaletteData(spriteData->badgePaletteBuffers[badgeID], &spriteData->badgePalettes[badgeID]) == FALSE) {
Heap_Free(spriteData->badgePalettes[badgeID]);
GF_ASSERT(FALSE);
}
} else {
GF_ASSERT(FALSE);
}
}
GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, TRUE);
}
void TrainerCard_DrawBadgeCaseSprites(TrainerCardSpriteData *spriteData, u8 *badgesObtained)
{
int badgeID;
SpriteResourcesHeader resourceData;
SpriteResourcesHeader_Init(&resourceData, 1, 1, 1, 1, 0xffffffff, 0xffffffff, FALSE, 1, spriteData->spriteResourceCollection[SPRITE_RESOURCE_CHAR], spriteData->spriteResourceCollection[SPRITE_RESOURCE_PLTT], spriteData->spriteResourceCollection[SPRITE_RESOURCE_CELL], spriteData->spriteResourceCollection[SPRITE_RESOURCE_ANIM], NULL, NULL);
u8 index;
AffineSpriteListTemplate template;
template.list = spriteData->spriteList;
template.resourceData = &resourceData;
template.position.x = 0;
template.position.y = 0;
template.position.z = 0;
template.affineScale.x = FX32_ONE;
template.affineScale.y = FX32_ONE;
template.affineScale.z = FX32_ONE;
template.affineZRotation = 0;
template.priority = 2;
template.vramType = NNS_G2D_VRAM_TYPE_2DMAIN;
template.heapID = HEAP_ID_TRAINER_CARD_SCREEN;
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
template.position.x = FX32_ONE * sBadgeCoordinates[badgeID].x;
template.position.y = FX32_ONE * sBadgeCoordinates[badgeID].y;
spriteData->sprites[badgeID] = SpriteList_AddAffine(&template);
Sprite_SetAnimateFlag(spriteData->sprites[badgeID], FALSE);
Sprite_SetAnim(spriteData->sprites[badgeID], badgeID);
if (!badgesObtained[badgeID]) {
Sprite_SetDrawFlag(spriteData->sprites[badgeID], FALSE);
}
}
index = TRAINER_CARD_TWO_SPARKLES_SPRITES_INDEX;
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
template.position.x = FX32_ONE * sSparkleCoordinates[badgeID].x;
template.position.y = FX32_ONE * sSparkleCoordinates[badgeID].y;
template.priority = 1;
spriteData->sprites[index + badgeID] = SpriteList_AddAffine(&template);
Sprite_SetAnimateFlag(spriteData->sprites[index + badgeID], TRUE);
Sprite_SetAnim(spriteData->sprites[index + badgeID], 8);
Sprite_SetDrawFlag(spriteData->sprites[index + badgeID], FALSE);
}
index += TRAINER_CARD_FOUR_SPARKLES_SPRITES_INDEX - TRAINER_CARD_TWO_SPARKLES_SPRITES_INDEX;
for (badgeID = 0; badgeID < MAX_BADGES; badgeID++) {
template.position.x = FX32_ONE * sSparkleCoordinates[badgeID].x;
template.position.y = FX32_ONE * sSparkleCoordinates[badgeID].y;
template.priority = 1;
spriteData->sprites[index + badgeID] = SpriteList_AddAffine(&template);
Sprite_SetAnimateFlag(spriteData->sprites[index + badgeID], TRUE);
Sprite_SetAnim(spriteData->sprites[index + badgeID], 9);
Sprite_SetDrawFlag(spriteData->sprites[index + badgeID], FALSE);
}
index += TRAINER_CARD_BADGE_CASE_BUTTON_EFFECT_SPRITE_INDEX - TRAINER_CARD_FOUR_SPARKLES_SPRITES_INDEX;
resourceData.priority = 0;
template.position.x = FX32_ONE * (12 * 8);
template.position.y = FX32_ONE * (17 * 8);
template.priority = 0;
spriteData->sprites[index] = SpriteList_AddAffine(&template);
Sprite_SetAnimateFlag(spriteData->sprites[index], FALSE);
Sprite_SetAnim(spriteData->sprites[index], 10);
Sprite_SetDrawFlag(spriteData->sprites[index], FALSE);
}
void TrainerCard_FreeSprites(TrainerCardSpriteData *spriteData)
{
u8 i;
for (i = 0; i < MAX_BADGES; i++) {
Heap_Free(spriteData->badgePaletteBuffers[i]);
}
SpriteTransfer_ResetCharTransfer(spriteData->spriteResources[0][0]);
SpriteTransfer_ResetPlttTransfer(spriteData->spriteResources[0][1]);
for (i = SPRITE_RESOURCE_CHAR; i < SPRITE_RESOURCE_MULTI_CELL; i++) {
SpriteResourceCollection_Delete(spriteData->spriteResourceCollection[i]);
}
SpriteList_Delete(spriteData->spriteList);
RenderOam_Free();
CharTransfer_Free();
PlttTransfer_Free();
}
void TrainerCard_DrawBadgeDirt(TrainerCardSpriteData *spriteData, u8 badgeID, u8 dirtLevel)
{
GF_ASSERT(badgeID < MAX_BADGES);
GF_ASSERT(dirtLevel <= 3);
NNSG2dImagePaletteProxy *paletteProxy = Sprite_GetPaletteProxy(spriteData->sprites[badgeID]);
u32 vramLocation = NNS_G2dGetImagePaletteLocation(paletteProxy, NNS_G2D_VRAM_TYPE_2DMAIN);
vramLocation += badgeID * PALETTE_SIZE_BYTES;
u8 *rawData = spriteData->badgePalettes[badgeID]->pRawData;
DC_FlushRange(&rawData[dirtLevel * PALETTE_SIZE_BYTES], PALETTE_SIZE_BYTES);
GX_LoadOBJPltt(&rawData[dirtLevel * PALETTE_SIZE_BYTES], vramLocation, PALETTE_SIZE_BYTES);
}
static void TrainerCard_InitCharPlttTransferBuffers(void)
{
CharTransferTemplate template = {
.maxTasks = 1,
.sizeMain = 2048,
.sizeSub = 0,
.heapID = HEAP_ID_TRAINER_CARD_SCREEN
};
CharTransfer_Init(&template);
PlttTransfer_Init(2, HEAP_ID_TRAINER_CARD_SCREEN);
CharTransfer_ClearBuffers();
PlttTransfer_Clear();
}

10
src/unk_0202854C.c
View File

@ -169,7 +169,7 @@ static int sub_02028638(Underground *underground)
return -1;
}
void sub_02028658(SaveData *saveData, int param1)
void sub_02028658(SaveData *saveData, int daysPassed)
{
Underground *v0 = SaveData_GetUnderground(saveData);
MATHRandContext16 v1;
@ -177,13 +177,13 @@ void sub_02028658(SaveData *saveData, int param1)
u8 v3[] = { 0, 1, 1, 3, 3, 5 };
int i, v5, v6, v7, j;
if (param1 <= 0) {
if (daysPassed <= 0) {
return;
}
v5 = param1;
v5 = daysPassed;
if (param1 > 99) {
if (daysPassed > 99) {
v5 = 99;
}
@ -204,7 +204,7 @@ void sub_02028658(SaveData *saveData, int param1)
}
}
v0->randomSeed = ARNG_Next(v0->randomSeed + param1);
v0->randomSeed = ARNG_Next(v0->randomSeed + daysPassed);
v0->unk_9AC_0 = 1;
}

20
src/unk_0203D1B8.c
View File

@ -54,7 +54,6 @@
#include "overlay058/ov58_021D0D80.h"
#include "overlay059/ov59_021D0D80.h"
#include "overlay064/ov64_0222DCE0.h"
#include "overlay071/ov71_0223B140.h"
#include "overlay072/ov72_0223D7A0.h"
#include "overlay080/ov80_021D0D80.h"
#include "overlay084/const_ov84_02241130.h"
@ -79,6 +78,7 @@
#include "overlay110/ov110_021D0D80.h"
#include "overlay111/ov111_021D0D80.h"
#include "savedata/save_table.h"
#include "trainer_card_screen/trainer_card_screen.h"
#include "bag.h"
#include "coins.h"
@ -153,7 +153,7 @@ FS_EXTERN_OVERLAY(overlay58);
FS_EXTERN_OVERLAY(overlay59);
FS_EXTERN_OVERLAY(overlay61);
FS_EXTERN_OVERLAY(overlay64);
FS_EXTERN_OVERLAY(overlay71);
FS_EXTERN_OVERLAY(trainer_card_screen);
FS_EXTERN_OVERLAY(overlay72);
FS_EXTERN_OVERLAY(options_menu);
FS_EXTERN_OVERLAY(choose_starter);
@ -1266,18 +1266,18 @@ void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int par
FieldTask_InitCall(param0, sub_0203DE98, v2);
}
void sub_0203E09C(FieldSystem *fieldSystem, TrainerCard *param1)
void FieldSystem_OpenTrainerCardScreen(FieldSystem *fieldSystem, TrainerCard *trainerCard)
{
FS_EXTERN_OVERLAY(overlay71);
FS_EXTERN_OVERLAY(trainer_card_screen);
static const ApplicationManagerTemplate v0 = {
ov71_0223B140,
ov71_0223B388,
ov71_0223B5B8,
FS_OVERLAY_ID(overlay71)
static const ApplicationManagerTemplate template = {
.init = TrainerCardScreen_Init,
.main = TrainerCardScreen_Main,
.exit = TrainerCardScreen_Exit,
.overlayID = FS_OVERLAY_ID(trainer_card_screen)
};
FieldSystem_StartChildProcess(fieldSystem, &v0, param1);
FieldSystem_StartChildProcess(fieldSystem, &template, trainerCard);
}
BOOL sub_0203E0AC(FieldSystem *fieldSystem, void *param1)

32
src/unk_020559DC.c
View File

@ -18,12 +18,12 @@
#include "special_encounter.h"
#include "system_data.h"
#include "system_vars.h"
#include "trainer_card_badge_dirt.h"
#include "unk_0202854C.h"
#include "unk_0202C858.h"
#include "unk_0202E2CC.h"
#include "unk_02055C50.h"
#include "unk_0206B9D8.h"
#include "unk_0206C2D0.h"
#include "unk_0206CCB0.h"
#include "vars_flags.h"
@ -48,15 +48,15 @@ void sub_020559DC(FieldSystem *fieldSystem)
inline_020559DC(fieldSystem, v2, &v0, &v1);
}
static void sub_02055A14(FieldSystem *fieldSystem, GameTime *param1, const RTCDate *param2)
static void sub_02055A14(FieldSystem *fieldSystem, GameTime *gameTime, const RTCDate *currentDate)
{
s32 v0 = RTC_ConvertDateToDay(param2);
s32 currentDay = RTC_ConvertDateToDay(currentDate);
if (v0 < param1->day) {
param1->day = v0;
} else if (v0 > param1->day) {
sub_02055AC0(fieldSystem, v0 - param1->day);
param1->day = v0;
if (currentDay < gameTime->day) {
gameTime->day = currentDay;
} else if (currentDay > gameTime->day) {
sub_02055AC0(fieldSystem, currentDay - gameTime->day);
gameTime->day = currentDay;
}
}
@ -84,27 +84,27 @@ static void inline_020559DC(FieldSystem *fieldSystem, GameTime *param1, const RT
}
}
static void sub_02055AC0(FieldSystem *fieldSystem, s32 param1)
static void sub_02055AC0(FieldSystem *fieldSystem, s32 daysPassed)
{
sub_02028658(FieldSystem_GetSaveData(fieldSystem), param1);
sub_02028658(FieldSystem_GetSaveData(fieldSystem), daysPassed);
sub_0203F1FC(fieldSystem);
sub_0206C2D0(fieldSystem->saveData, param1);
RecordMixedRNG_AdvanceEntries(SaveData_GetRecordMixedRNG(fieldSystem->saveData), param1);
TrainerCard_AccumulateBadgeDirt(fieldSystem->saveData, daysPassed);
RecordMixedRNG_AdvanceEntries(SaveData_GetRecordMixedRNG(fieldSystem->saveData), daysPassed);
SpecialEncounter_SetMixedRecordDailies(SaveData_GetSpecialEncounters(fieldSystem->saveData), RecordMixedRNG_GetRand(SaveData_GetRecordMixedRNG(fieldSystem->saveData)));
{
Party *v0;
v0 = SaveData_GetParty(fieldSystem->saveData);
Party_UpdatePokerusStatus(v0, param1);
Party_UpdatePokerusStatus(v0, daysPassed);
}
{
VarsFlags *varsFlags = SaveData_GetVarsFlags(fieldSystem->saveData);
u16 deadlineInDays = SystemVars_GetNewsPressDeadline(varsFlags);
if (deadlineInDays > param1) {
deadlineInDays -= param1;
if (deadlineInDays > daysPassed) {
deadlineInDays -= daysPassed;
} else {
deadlineInDays = 0;
}
@ -113,7 +113,7 @@ static void sub_02055AC0(FieldSystem *fieldSystem, s32 param1)
}
{
SystemVars_SynchronizeJubilifeLotteryTrainerID(fieldSystem->saveData, param1);
SystemVars_SynchronizeJubilifeLotteryTrainerID(fieldSystem->saveData, daysPassed);
}
{

2
src/unk_0205A0D8.c
View File

@ -1041,7 +1041,7 @@ static BOOL sub_0205B140(FieldTask *param0)
}
break;
case 3:
sub_0203E09C(fieldSystem, v2);
FieldSystem_OpenTrainerCardScreen(fieldSystem, v2);
v1->unk_28++;
break;
case 4:

2
src/unk_0205B33C.c
View File

@ -1372,7 +1372,7 @@ void *sub_0205C17C(UnkStruct_0205B43C *param0)
param0->unk_188[0] = TrainerCard_New(HEAP_ID_SYSTEM);
param0->unk_188[1] = TrainerCard_New(HEAP_ID_SYSTEM);
TrainerCard_Init(0, 0, 0, sub_0205CA14(TrainerInfo_Gender(param0->unk_08), TrainerInfo_Appearance(param0->unk_08), 0), param0->fieldSystem, param0->unk_184);
TrainerCard_Init(FALSE, FALSE, 0, sub_0205CA14(TrainerInfo_Gender(param0->unk_08), TrainerInfo_Appearance(param0->unk_08), 0), param0->fieldSystem, param0->unk_184);
return (void *)param0->unk_188[CommSys_CurNetId() ^ 1];
}

14
src/unk_0205C980.c
View File

@ -59,27 +59,27 @@ int TrainerInfo_GetAppearanceIndex(u32 trainerId, int trainerGender, u32 variant
return TRAINER_APPEARANCES[v1][0];
}
static int sub_0205C9E0(int param0, int param1)
static int sub_0205C9E0(int gender, int param1)
{
int v0;
for (v0 = 0; v0 < 16 / 2; v0++) {
if (TRAINER_APPEARANCES[v0 + (param0 * (16 / 2))][0] == param1) {
return v0 + (param0 * (16 / 2));
if (TRAINER_APPEARANCES[v0 + (gender * (16 / 2))][0] == param1) {
return v0 + (gender * (16 / 2));
}
}
return 0;
}
int sub_0205CA0C(int param0, int param1)
int sub_0205CA0C(int gender, int param1)
{
return sub_0205C9E0(param0, param1);
return sub_0205C9E0(gender, param1);
}
int sub_0205CA14(int param0, int param1, int param2)
int sub_0205CA14(int gender, int param1, int param2)
{
int v0 = sub_0205C9E0(param0, param1);
int v0 = sub_0205C9E0(gender, param1);
switch (param2) {
case 0:

47
src/unk_0206C2D0.c
View File

@ -1,47 +0,0 @@
#include "unk_0206C2D0.h"
#include <nitro.h>
#include <string.h>
#include "save_player.h"
#include "savedata.h"
#include "trainer_card_save_data.h"
#include "trainer_info.h"
void sub_0206C2D0(SaveData *saveData, const s32 param1)
{
u8 v0;
int v1;
TrainerCardSaveData *v2;
TrainerCardBadge *v3;
TrainerInfo *v4;
if (param1 <= 0) {
return;
}
v2 = SaveData_GetTrainerCardSaveData(saveData);
v3 = TrainerCardSaveData_GetTrainerCardBadges(v2);
v4 = SaveData_GetTrainerInfo(saveData);
for (v0 = 0; v0 < 8; v0++) {
if (TrainerInfo_HasBadge(v4, v0) == 0) {
continue;
}
v1 = TrainerCardBadge_GetCleanliness(v0, v3);
if ((0 < v1) && (v1 < 200)) {
v1 -= (10 * param1);
} else {
GF_ASSERT(v1 < 200);
v1 = 0;
}
if (v1 < 0) {
v1 = 0;
}
TrainerCardBadge_SetCleanliness(v0, v1, v3);
}
}

4
src/unk_02073838.c
View File

@ -22,7 +22,7 @@ static void sub_020739D8(UnkStruct_02073974 *param0, void *param1, u32 param2);
static const VecFx32 Unk_020F0544 = {
FX32_ONE,
FX32_ONE,
FX32_ONE
FX32_ONE,
};
static const MtxFx33 Unk_020F0550 = {
@ -34,7 +34,7 @@ static const MtxFx33 Unk_020F0550 = {
0x0,
0x0,
0x0,
FX32_ONE
FX32_ONE,
};
void sub_02073838(UnkStruct_02073838 *param0)

2
src/unk_0207E0B8.c
View File

@ -260,7 +260,7 @@ static int sub_0207E0B8(ApplicationManager *appMan, int *param1)
v1 = NARC_ctor(NARC_INDEX_GRAPHIC__PL_PLIST_GRA, HEAP_ID_12);
v0 = sub_0207ECC0(appMan);
StartScreenFade(FADE_MAIN_THEN_SUB, FADE_TYPE_UNK_3, FADE_TYPE_UNK_3, COLOR_BLACK, 6, 1, HEAP_ID_12);
StartScreenFade(FADE_MAIN_THEN_SUB, FADE_TYPE_DOWNWARD_IN, FADE_TYPE_DOWNWARD_IN, COLOR_BLACK, 6, 1, HEAP_ID_12);
sub_0207EDC0(v0);
sub_0207E8C0();
sub_0207E918(v0->unk_00);