From b03a102605ff2a771da434e6fa3d9ff22747e28e Mon Sep 17 00:00:00 2001 From: VicSevenT Date: Sat, 11 Oct 2025 15:55:35 -0500 Subject: [PATCH] Document Poketch Alarm Clock (Overlay 45) (#795) --- .../poketch/alarm_clock/graphics.h | 50 ++ include/overlay045/ov45_022566EC.h | 16 - include/overlay045/struct_ov45_022566EC_1.h | 12 - .../overlay045/struct_ov45_022566EC_decl.h | 6 - include/rtc.h | 2 +- platinum.us/main.lsf | 6 +- platinum.us/sbins_shared.sha1 | 2 +- .../poketch/alarm_clock/graphics.c | 417 ++++++++++++++++ src/applications/poketch/alarm_clock/main.c | 445 +++++++++++++++++ src/applications/poketch/analog_watch/main.c | 4 +- src/applications/poketch/digital_watch/main.c | 4 +- src/applications/poketch/poketch_system.c | 4 +- src/game_opening/ov77_021D6C70.c | 2 +- src/meson.build | 4 +- src/overlay045/ov45_022561C0.c | 463 ------------------ src/overlay045/ov45_022566EC.c | 426 ---------------- src/pokemon.c | 2 +- src/rtc.c | 4 +- 18 files changed, 929 insertions(+), 940 deletions(-) create mode 100644 include/applications/poketch/alarm_clock/graphics.h delete mode 100644 include/overlay045/ov45_022566EC.h delete mode 100644 include/overlay045/struct_ov45_022566EC_1.h delete mode 100644 include/overlay045/struct_ov45_022566EC_decl.h create mode 100644 src/applications/poketch/alarm_clock/graphics.c create mode 100644 src/applications/poketch/alarm_clock/main.c delete mode 100644 src/overlay045/ov45_022561C0.c delete mode 100644 src/overlay045/ov45_022566EC.c diff --git a/include/applications/poketch/alarm_clock/graphics.h b/include/applications/poketch/alarm_clock/graphics.h new file mode 100644 index 0000000000..75d079c8c9 --- /dev/null +++ b/include/applications/poketch/alarm_clock/graphics.h @@ -0,0 +1,50 @@ +#ifndef POKEPLATINUM_POKETCH_ALARM_CLOCK_GRAPHICS_H +#define POKEPLATINUM_POKETCH_ALARM_CLOCK_GRAPHICS_H + +#include "applications/poketch/poketch_animation.h" +#include "applications/poketch/poketch_task.h" + +#include "bg_window.h" + +#define ALARM_CLOCK_TASK_SLOTS 8 + +#define NUM_SPRITES 13 + +typedef struct AlarmClockData { + u8 alarmSet; + s8 currentHour; + s8 currentMinute; + s8 alarmHour; + s8 alarmMinute; +} AlarmClockData; + +typedef struct AlarmClockGraphics { + const AlarmClockData *clockData; + BgConfig *bgConfig; + u32 activeTasks[POKETCH_TASK_SLOT_BASE + ALARM_CLOCK_TASK_SLOTS]; + PoketchAnimation_AnimationManager *animMan; + PoketchAnimation_AnimatedSpriteData *sprites[NUM_SPRITES]; + PoketchAnimation_SpriteData alarmSprites; + PoketchAnimation_SpriteData digitSprites; + BOOL stopAlarm; + u32 digitBlinkTimer; + BOOL showDigits; +} AlarmClockGraphics; + +enum AlarmClockGraphicsTask { + ALARM_CLOCK_GRAPHICS_INIT = 0, + ALARM_CLOCK_GRAPHICS_FREE, + ALARM_CLOCK_GRAPHICS_SHOW_CURRENT_TIME, + ALARM_CLOCK_GRAPHICS_ENTER_EDIT_MODE, + ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS, + ALARM_CLOCK_GRAPHICS_SOUND_ALARM, +}; + +BOOL PoketchAlarmClockGraphics_New(AlarmClockGraphics **dest, const AlarmClockData *clockData, BgConfig *bgConfig); +void PoketchAlarmClockGraphics_Free(AlarmClockGraphics *graphics); +void PoketchAlarmClockGraphics_StartTask(AlarmClockGraphics *graphics, enum AlarmClockGraphicsTask taskID); +BOOL PoketchAlarmClockGraphics_TaskIsNotActive(AlarmClockGraphics *graphics, enum AlarmClockGraphicsTask taskID); +BOOL PoketchAlarmClockGraphics_NoActiveTasks(AlarmClockGraphics *graphics); +void StopSoundingAlarm(AlarmClockGraphics *graphics); + +#endif // POKEPLATINUM_POKETCH_ALARM_CLOCK_GRAPHICS_H diff --git a/include/overlay045/ov45_022566EC.h b/include/overlay045/ov45_022566EC.h deleted file mode 100644 index 3ea8c231c7..0000000000 --- a/include/overlay045/ov45_022566EC.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef POKEPLATINUM_OV45_022566EC_H -#define POKEPLATINUM_OV45_022566EC_H - -#include "overlay045/struct_ov45_022566EC_1.h" -#include "overlay045/struct_ov45_022566EC_decl.h" - -#include "bg_window.h" - -BOOL ov45_022566EC(UnkStruct_ov45_022566EC **param0, const UnkStruct_ov45_022566EC_1 *param1, BgConfig *param2); -void ov45_02256728(UnkStruct_ov45_022566EC *param0); -void ov45_02256918(UnkStruct_ov45_022566EC *param0, u32 param1); -BOOL ov45_0225693C(UnkStruct_ov45_022566EC *param0, u32 param1); -BOOL ov45_02256948(UnkStruct_ov45_022566EC *param0); -void ov45_02256C90(UnkStruct_ov45_022566EC *param0); - -#endif // POKEPLATINUM_OV45_022566EC_H diff --git a/include/overlay045/struct_ov45_022566EC_1.h b/include/overlay045/struct_ov45_022566EC_1.h deleted file mode 100644 index 54abaf9a5f..0000000000 --- a/include/overlay045/struct_ov45_022566EC_1.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_OV45_022566EC_1_H -#define POKEPLATINUM_STRUCT_OV45_022566EC_1_H - -typedef struct { - u8 unk_00; - s8 unk_01; - s8 unk_02; - s8 unk_03; - s8 unk_04; -} UnkStruct_ov45_022566EC_1; - -#endif // POKEPLATINUM_STRUCT_OV45_022566EC_1_H diff --git a/include/overlay045/struct_ov45_022566EC_decl.h b/include/overlay045/struct_ov45_022566EC_decl.h deleted file mode 100644 index d56ac353ba..0000000000 --- a/include/overlay045/struct_ov45_022566EC_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_OV45_022566EC_DECL_H -#define POKEPLATINUM_STRUCT_OV45_022566EC_DECL_H - -typedef struct UnkStruct_ov45_022566EC_t UnkStruct_ov45_022566EC; - -#endif // POKEPLATINUM_STRUCT_OV45_022566EC_DECL_H diff --git a/include/rtc.h b/include/rtc.h index f95b59982f..0667df14d9 100644 --- a/include/rtc.h +++ b/include/rtc.h @@ -17,7 +17,7 @@ static inline BOOL IsLeapYear(u32 year) void InitRTC(void); void UpdateRTC(void); void GetCurrentDateTime(RTCDate *date, RTCTime *time); -void GetCurrentTime(RTCTime *time); +void RTC_GetCurrentTime(RTCTime *time); void GetCurrentDate(RTCDate *date); int GetSecondsSinceMidnight(void); s64 GetTimestamp(void); diff --git a/platinum.us/main.lsf b/platinum.us/main.lsf index 527aa7b37d..eaefc7acdb 100644 --- a/platinum.us/main.lsf +++ b/platinum.us/main.lsf @@ -1012,11 +1012,11 @@ Overlay overlay44 Object main.nef.p/src_overlay044_ov44_022565BC.c.o } -Overlay overlay45 +Overlay poketch_alarm_clock { After overlay25 - Object main.nef.p/src_overlay045_ov45_022561C0.c.o - Object main.nef.p/src_overlay045_ov45_022566EC.c.o + Object main.nef.p/src_applications_poketch_alarm_clock_main.c.o + Object main.nef.p/src_applications_poketch_alarm_clock_graphics.c.o } Overlay overlay46 diff --git a/platinum.us/sbins_shared.sha1 b/platinum.us/sbins_shared.sha1 index 08d3cf7a69..882c549f23 100644 --- a/platinum.us/sbins_shared.sha1 +++ b/platinum.us/sbins_shared.sha1 @@ -44,7 +44,7 @@ a5b13f54d5303140b3169c794db0fd04c9c2dc22 *poketch_roulette.sbin ba5baba0ff38e940d333dbea89e4c510b6998922 *overlay42.sbin 261b64d5fd09a304a5d7e78a18b44a6ecfe7ec93 *poketch_move_tester.sbin 5dd962600f238f162c0999dcb8a134c9df134293 *overlay44.sbin -e722ce81a98e1d78011e179f008a4cac37e20610 *overlay45.sbin +e722ce81a98e1d78011e179f008a4cac37e20610 *poketch_alarm_clock.sbin 87cd3ac2574737177d399a8cf8a8374c9599e38b *overlay46.sbin b38da9fe733a6a1213ff217f4e2788e3ae2011a4 *overlay47.sbin 70266035d948ee5a826b06a3a1b908a50af050c9 *overlay48.sbin diff --git a/src/applications/poketch/alarm_clock/graphics.c b/src/applications/poketch/alarm_clock/graphics.c new file mode 100644 index 0000000000..8d050eb38e --- /dev/null +++ b/src/applications/poketch/alarm_clock/graphics.c @@ -0,0 +1,417 @@ +#include "applications/poketch/alarm_clock/graphics.h" + +#include + +#include "applications/poketch/poketch_animation.h" +#include "applications/poketch/poketch_graphics.h" +#include "applications/poketch/poketch_system.h" +#include "applications/poketch/poketch_task.h" + +#include "bg_window.h" +#include "graphics.h" +#include "heap.h" +#include "sound_playback.h" +#include "sys_task_manager.h" + +#define SPRITE_ALARM_SET_BUTTON 0 +#define SPRITE_EAR_LEFT 1 +#define SPRITE_EAR_RIGHT 2 +#define SPRITE_EYE_LEFT 3 +#define SPRITE_EYE_RIGHT 4 +#define SPRITE_HOUR_UP_BUTTON 5 +#define SPRITE_HOUR_DOWN_BUTTON 6 +#define SPRITE_MINUTE_UP_BUTTON 7 +#define SPRITE_MINUTE_DOWN_BUTTON 8 +#define SPRITE_HOUR_TENS_DIGIT 9 +#define SPRITE_HOUR_ONES_DIGIT 10 +#define SPRITE_MINUTE_TENS_DIGIT 11 +#define SPRITE_MINUTE_ONES_DIGIT 12 + +static void SetupSprites(AlarmClockGraphics *graphics, const AlarmClockData *clockData); +static void UnloadSprites(AlarmClockGraphics *graphics); +static void UpdateDigits(AlarmClockGraphics *graphics, u32 hour, u32 minute); + +static void EndTask(PoketchTaskManager *taskMan); +static void Task_DrawBackground(SysTask *task, void *taskMan); +static void Task_FreeBackground(SysTask *task, void *taskMan); +static void Task_ShowCurrentTime(SysTask *task, void *taskMan); +static void Task_EnterEditMode(SysTask *task, void *taskMan); +static void Task_UpdateDigits(SysTask *task, void *taskMan); +static void Task_SoundAlarm(SysTask *task, void *taskMan); + +BOOL PoketchAlarmClockGraphics_New(AlarmClockGraphics **dest, const AlarmClockData *clockData, BgConfig *bgConfig) +{ + AlarmClockGraphics *graphics = Heap_Alloc(HEAP_ID_POKETCH_APP, sizeof(AlarmClockGraphics)); + + if (graphics != NULL) { + PoketchTask_InitActiveTaskList(graphics->activeTasks, ALARM_CLOCK_TASK_SLOTS); + graphics->clockData = clockData; + graphics->bgConfig = PoketchGraphics_GetBgConfig(); + graphics->animMan = PoketchGraphics_GetAnimationManager(); + SetupSprites(graphics, clockData); + *dest = graphics; + return TRUE; + } + + return FALSE; +} + +void PoketchAlarmClockGraphics_Free(AlarmClockGraphics *graphics) +{ + if (graphics != NULL) { + UnloadSprites(graphics); + Heap_Free(graphics); + } +} + +static void SetupSprites(AlarmClockGraphics *graphics, const AlarmClockData *clockData) +{ + static const PoketchAnimation_AnimationData animationData[] = { + { + .translation = { FX32_CONST(192), FX32_CONST(104) }, + .animIdx = 3, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(48), FX32_CONST(48) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(144), FX32_CONST(48) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_H, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(56), FX32_CONST(80) }, + .animIdx = 4, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(136), FX32_CONST(80) }, + .animIdx = 4, + .flip = NNS_G2D_RENDERERFLIP_H, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(72), FX32_CONST(120) }, + .animIdx = 6, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(72), FX32_CONST(164) }, + .animIdx = 6, + .flip = NNS_G2D_RENDERERFLIP_V, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(120), FX32_CONST(120) }, + .animIdx = 6, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(120), FX32_CONST(164) }, + .animIdx = 6, + .flip = NNS_G2D_RENDERERFLIP_V, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(64), FX32_CONST(144) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(80), FX32_CONST(144) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(112), FX32_CONST(144) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + { + .translation = { FX32_CONST(128), FX32_CONST(144) }, + .animIdx = 0, + .flip = NNS_G2D_RENDERERFLIP_NONE, + .oamPriority = 2, + .priority = 0, + .hasAffineTransform = FALSE, + }, + }; + + Graphics_LoadObjectTiles(NARC_INDEX_GRAPHIC__POKETCH, 2, DS_SCREEN_SUB, 0, 0, TRUE, HEAP_ID_POKETCH_APP); + Graphics_LoadObjectTiles(NARC_INDEX_GRAPHIC__POKETCH, 79, DS_SCREEN_SUB, POKETCH_DIGITS_NCGR_NUM_TILES * TILE_SIZE_4BPP, 0, TRUE, HEAP_ID_POKETCH_APP); + + PoketchAnimation_LoadSpriteFromNARC(&graphics->alarmSprites, NARC_INDEX_GRAPHIC__POKETCH, 77, 78, HEAP_ID_POKETCH_APP); + PoketchAnimation_LoadSpriteFromNARC(&graphics->digitSprites, NARC_INDEX_GRAPHIC__POKETCH, 3, 4, HEAP_ID_POKETCH_APP); + + for (int i = 0; i < NUM_SPRITES; i++) { + if (i >= SPRITE_HOUR_TENS_DIGIT && i <= SPRITE_MINUTE_ONES_DIGIT) { + graphics->sprites[i] = PoketchAnimation_SetupNewAnimatedSprite(graphics->animMan, &animationData[i], &graphics->digitSprites); + } else { + graphics->sprites[i] = PoketchAnimation_SetupNewAnimatedSprite(graphics->animMan, &animationData[i], &graphics->alarmSprites); + PoketchAnimation_SetSpriteCharNo(graphics->sprites[i], POKETCH_DIGITS_NCGR_NUM_TILES); + } + } + + if (clockData->alarmSet) { + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_ALARM_SET_BUTTON], 3); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_LEFT], 5); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_RIGHT], 5); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_UP_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_DOWN_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_UP_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_DOWN_BUTTON], TRUE); + UpdateDigits(graphics, clockData->currentHour, clockData->currentMinute); + } else { + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_ALARM_SET_BUTTON], 2); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_LEFT], 5); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_RIGHT], 4); + UpdateDigits(graphics, clockData->alarmHour, clockData->alarmMinute); + } +} + +static void UnloadSprites(AlarmClockGraphics *graphics) +{ + for (int i = 0; i < NUM_SPRITES; i++) { + if (graphics->sprites[i]) { + PoketchAnimation_RemoveAnimatedSprite(graphics->animMan, graphics->sprites[i]); + } + } + + PoketchAnimation_FreeSpriteData(&graphics->alarmSprites); + PoketchAnimation_FreeSpriteData(&graphics->digitSprites); +} + +static void UpdateDigits(AlarmClockGraphics *graphics, u32 hour, u32 minute) +{ + CP_SetDiv32_32(hour, 10); + + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_HOUR_TENS_DIGIT], CP_GetDivResult32()); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_HOUR_ONES_DIGIT], CP_GetDivRemainder32()); + + CP_SetDiv32_32(minute, 10); + + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_MINUTE_TENS_DIGIT], CP_GetDivResult32()); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_MINUTE_ONES_DIGIT], CP_GetDivRemainder32()); +} + +static const PoketchTask sAlarmClockTasks[] = { + { ALARM_CLOCK_GRAPHICS_INIT, Task_DrawBackground, 0 }, + { ALARM_CLOCK_GRAPHICS_FREE, Task_FreeBackground, 0 }, + { ALARM_CLOCK_GRAPHICS_SHOW_CURRENT_TIME, Task_ShowCurrentTime, 0 }, + { ALARM_CLOCK_GRAPHICS_ENTER_EDIT_MODE, Task_EnterEditMode, 0 }, + { ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS, Task_UpdateDigits, 0 }, + { ALARM_CLOCK_GRAPHICS_SOUND_ALARM, Task_SoundAlarm, 0 }, + { 0 } +}; + +void PoketchAlarmClockGraphics_StartTask(AlarmClockGraphics *graphics, enum AlarmClockGraphicsTask taskID) +{ + PoketchTask_Start(sAlarmClockTasks, taskID, graphics, graphics->clockData, graphics->activeTasks, 2, HEAP_ID_POKETCH_APP); +} + +BOOL PoketchAlarmClockGraphics_TaskIsNotActive(AlarmClockGraphics *graphics, enum AlarmClockGraphicsTask taskID) +{ + return PoketchTask_TaskIsNotActive(graphics->activeTasks, taskID); +} + +BOOL PoketchAlarmClockGraphics_NoActiveTasks(AlarmClockGraphics *graphics) +{ + return PoketchTask_NoActiveTasks(graphics->activeTasks); +} + +static void EndTask(PoketchTaskManager *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + PoketchTask_EndTask(graphics->activeTasks, taskMan); +} + +static void Task_DrawBackground(SysTask *task, void *taskMan) +{ + static const BgTemplate bgTemplate = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0x7000, + .charBase = GX_BG_CHARBASE_0x00000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 2, + .areaOver = 0, + .mosaic = FALSE, + }; + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + + Bg_InitFromTemplate(graphics->bgConfig, BG_LAYER_SUB_2, &bgTemplate, BG_TYPE_STATIC); + Graphics_LoadTilesToBgLayer(NARC_INDEX_GRAPHIC__POKETCH, 76, graphics->bgConfig, BG_LAYER_SUB_2, 0, 0, TRUE, HEAP_ID_POKETCH_APP); + Graphics_LoadTilemapToBgLayer(NARC_INDEX_GRAPHIC__POKETCH, 75, graphics->bgConfig, BG_LAYER_SUB_2, 0, 0, TRUE, HEAP_ID_POKETCH_APP); + + PoketchGraphics_LoadActivePalette(0, 0); + Bg_CopyTilemapBufferToVRAM(graphics->bgConfig, BG_LAYER_SUB_2); + + GXSDispCnt dispCnt = GXS_GetDispCnt(); + GXS_SetVisiblePlane(dispCnt.visiblePlane | GX_PLANEMASK_BG2); + + EndTask(taskMan); +} + +static void Task_FreeBackground(SysTask *task, void *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + + switch (PoketchTask_GetState(taskMan)) { + case 0: + StopSoundingAlarm(graphics); + PoketchTask_IncrementState(taskMan); + break; + case 1: + if (PoketchAlarmClockGraphics_TaskIsNotActive(graphics, ALARM_CLOCK_GRAPHICS_SOUND_ALARM)) { + Bg_FreeTilemapBuffer(graphics->bgConfig, BG_LAYER_SUB_2); + EndTask(taskMan); + } + break; + } +} + +static void Task_ShowCurrentTime(SysTask *task, void *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + const AlarmClockData *clockData = PoketchTask_GetConstTaskData(taskMan); + + PoketchSystem_PlaySoundEffect(SEQ_SE_DP_POKETCH_003); + + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_ALARM_SET_BUTTON], 3); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_LEFT], 5); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_RIGHT], 5); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_LEFT], 0); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_RIGHT], 0); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_UP_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_DOWN_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_UP_BUTTON], TRUE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_DOWN_BUTTON], TRUE); + UpdateDigits(graphics, clockData->currentHour, clockData->currentMinute); + + EndTask(taskMan); +} + +static void Task_EnterEditMode(SysTask *task, void *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + const AlarmClockData *clockData = PoketchTask_GetConstTaskData(taskMan); + + PoketchSystem_PlaySoundEffect(SEQ_SE_DP_POKETCH_003); + + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_ALARM_SET_BUTTON], 2); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_LEFT], 5); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_RIGHT], 4); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_LEFT], 0); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_RIGHT], 0); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_UP_BUTTON], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_DOWN_BUTTON], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_UP_BUTTON], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_DOWN_BUTTON], FALSE); + UpdateDigits(graphics, clockData->alarmHour, clockData->alarmMinute); + + EndTask(taskMan); +} + +static void Task_UpdateDigits(SysTask *task, void *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + const AlarmClockData *clockData = PoketchTask_GetConstTaskData(taskMan); + + if (clockData->alarmSet) { + UpdateDigits(graphics, clockData->currentHour, clockData->currentMinute); + } else { + UpdateDigits(graphics, clockData->alarmHour, clockData->alarmMinute); + } + + EndTask(taskMan); +} + +static void Task_SoundAlarm(SysTask *task, void *taskMan) +{ + AlarmClockGraphics *graphics = PoketchTask_GetTaskData(taskMan); + const AlarmClockData *clockData = PoketchTask_GetConstTaskData(taskMan); + + switch (PoketchTask_GetState(taskMan)) { + case 0: + graphics->stopAlarm = FALSE; + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_LEFT], 4); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EYE_RIGHT], 4); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_LEFT], 1); + PoketchAnimation_UpdateAnimationIdx(graphics->sprites[SPRITE_EAR_RIGHT], 1); + PoketchSystem_PlaySoundEffect(SEQ_SE_DP_POKETCH_003); + PoketchSystem_PlayCry(SPECIES_LOUDRED, 0); + graphics->digitBlinkTimer = 0; + graphics->showDigits = FALSE; + PoketchTask_IncrementState(taskMan); + break; + case 1: + if (graphics->stopAlarm) { + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_TENS_DIGIT], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_ONES_DIGIT], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_TENS_DIGIT], FALSE); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_ONES_DIGIT], FALSE); + EndTask(taskMan); + return; + } + + if (!Sound_IsPokemonCryPlaying()) { + PoketchSystem_PlayCry(SPECIES_LOUDRED, 0); + } + + if (++graphics->digitBlinkTimer >= 15) { + graphics->digitBlinkTimer = 0; + graphics->showDigits ^= 1; + + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_TENS_DIGIT], graphics->showDigits); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_HOUR_ONES_DIGIT], graphics->showDigits); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_TENS_DIGIT], graphics->showDigits); + PoketchAnimation_HideSprite(graphics->sprites[SPRITE_MINUTE_ONES_DIGIT], graphics->showDigits); + } + break; + } +} + +void StopSoundingAlarm(AlarmClockGraphics *graphics) +{ + graphics->stopAlarm = TRUE; +} diff --git a/src/applications/poketch/alarm_clock/main.c b/src/applications/poketch/alarm_clock/main.c new file mode 100644 index 0000000000..afcc62423b --- /dev/null +++ b/src/applications/poketch/alarm_clock/main.c @@ -0,0 +1,445 @@ +#include +#include + +#include "generated/sdat.h" + +#include "applications/poketch/alarm_clock/graphics.h" +#include "applications/poketch/poketch_button.h" +#include "applications/poketch/poketch_system.h" + +#include "bg_window.h" +#include "heap.h" +#include "poketch.h" +#include "rtc.h" +#include "sys_task.h" +#include "sys_task_manager.h" +#include "touch_screen.h" + +#define BUTTON_SET_ALARM 0 +#define BUTTON_EDIT_ALARM 1 +#define BUTTON_HOUR_UP 2 +#define BUTTON_HOUR_DOWN 3 +#define BUTTON_MINUTE_UP 4 +#define BUTTON_MINUTE_DOWN 5 + +typedef struct PoketchAlarmClock { + u8 state; + u8 subState; + u8 shouldExit; + AlarmClockData clockData; + AlarmClockGraphics *graphics; + PoketchSystem *poketchSys; + Poketch *poketch; + PoketchButtonManager *buttonManager; + u32 pressedButton; + u32 buttonState; + RTCTime currentTime; + BOOL alwaysFalse; + BOOL currentTimeLoaded; +} PoketchAlarmClock; + +typedef BOOL (*StateFunc)(PoketchAlarmClock *); + +enum AlarmClockState { + STATE_LOAD_APP = 0, + STATE_EDITING_ALARM, + STATE_ALARM_SET, + STATE_ALARM_BLARING, + STATE_SHUTDOWN, +}; + +static void NitroStaticInit(void); + +static BOOL New(void **appData, PoketchSystem *poketchSys, BgConfig *bgConfig, u32 appID); +static BOOL Init(PoketchAlarmClock *appData, PoketchSystem *poketchSys, BgConfig *bgConfig, u32 appID); +static void Free(PoketchAlarmClock *appData); +static void Exit(void *appData); +static void ButtonCallback(u32 buttonID, u32 buttonState, u32 touchState, void *appData); +static void InitCurrentTime(AlarmClockData *clockData); + +static void Task_Main(SysTask *task, void *appData); +static void ChangeState(PoketchAlarmClock *appData, enum AlarmClockState newState); +static BOOL State_LoadApp(PoketchAlarmClock *appData); +static BOOL State_EditingAlarm(PoketchAlarmClock *appData); +static BOOL State_AlarmSet(PoketchAlarmClock *appData); +static BOOL State_AlarmBlaring(PoketchAlarmClock *appData); +static BOOL State_UnloadApp(PoketchAlarmClock *appData); + +static BOOL AlwaysFalse(PoketchAlarmClock *appData); +static void UpdateCurrentTime(PoketchAlarmClock *appData); +static BOOL GetCurrentTime(PoketchAlarmClock *appData, u32 *hour, u32 *minute); +static BOOL ActivateAlarm(AlarmClockData *clockData); + +static void NitroStaticInit(void) +{ + PoketchSystem_SetAppFunctions(New, Exit); +} + +static BOOL New(void **appData, PoketchSystem *poketchSys, BgConfig *bgConfig, u32 appID) +{ + PoketchAlarmClock *alarmClock = Heap_Alloc(HEAP_ID_POKETCH_APP, sizeof(PoketchAlarmClock)); + + if (alarmClock != NULL) { + if (Init(alarmClock, poketchSys, bgConfig, appID)) { + if (SysTask_Start(Task_Main, alarmClock, 1) != NULL) { + *appData = alarmClock; + return TRUE; + } + } + + Heap_Free(alarmClock); + } + + return FALSE; +} + +static BOOL Init(PoketchAlarmClock *appData, PoketchSystem *poketchSys, BgConfig *bgConfig, u32 appID) +{ + static const TouchScreenRect sButtonHitBoxes[] = { + [BUTTON_SET_ALARM] = { .rect = { .top = 72, .bottom = 104, .left = 176, .right = 208 } }, + [BUTTON_EDIT_ALARM] = { .rect = { .top = 104, .bottom = 136, .left = 176, .right = 208 } }, + [BUTTON_HOUR_UP] = { .rect = { .top = 112, .bottom = 128, .left = 64, .right = 80 } }, + [BUTTON_HOUR_DOWN] = { .rect = { .top = 160, .bottom = 176, .left = 64, .right = 80 } }, + [BUTTON_MINUTE_UP] = { .rect = { .top = 112, .bottom = 128, .left = 112, .right = 128 } }, + [BUTTON_MINUTE_DOWN] = { .rect = { .top = 160, .bottom = 176, .left = 112, .right = 128 } }, + }; + + appData->poketch = PoketchSystem_GetPoketchData(poketchSys); + appData->clockData.alarmSet = Poketch_IsAlarmSet(appData->poketch); + + u32 hour, minute; + Poketch_AlarmTime(appData->poketch, &hour, &minute); + + appData->clockData.alarmHour = hour; + appData->clockData.alarmMinute = minute; + + InitCurrentTime(&appData->clockData); + + if (PoketchAlarmClockGraphics_New(&appData->graphics, &appData->clockData, bgConfig)) { + appData->state = STATE_LOAD_APP; + appData->subState = 0; + appData->shouldExit = FALSE; + appData->buttonManager = PoketchButtonManager_New(sButtonHitBoxes, NELEMS(sButtonHitBoxes), ButtonCallback, appData, HEAP_ID_POKETCH_APP); + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + + PoketchButtonManager_SetRepeatTime(appData->buttonManager, 2, 4); + PoketchButtonManager_SetRepeatTime(appData->buttonManager, 3, 4); + PoketchButtonManager_SetRepeatTime(appData->buttonManager, 4, 4); + PoketchButtonManager_SetRepeatTime(appData->buttonManager, 5, 4); + + appData->alwaysFalse = FALSE; + appData->currentTimeLoaded = FALSE; + appData->poketchSys = poketchSys; + + return TRUE; + } + + return FALSE; +} + +static void InitCurrentTime(AlarmClockData *clockData) +{ + RTCTime time; + + RTC_GetCurrentTime(&time); + + if (time.hour >= 24) { + time.hour %= 24; + } + + if (time.minute >= 60) { + time.hour %= 60; + } + + clockData->currentHour = time.hour; + clockData->currentMinute = time.minute; +} + +static void Free(PoketchAlarmClock *appData) +{ + PoketchButtonManager_Free(appData->buttonManager); + PoketchAlarmClockGraphics_Free(appData->graphics); + + Heap_Free(appData); +} + +static void ButtonCallback(u32 buttonID, u32 buttonState, u32 touchState, void *appData) +{ + PoketchAlarmClock *alarmClock = appData; + + alarmClock->pressedButton = buttonID; + alarmClock->buttonState = buttonState; +} + +static void Task_Main(SysTask *task, void *appData) +{ + static const StateFunc stateFuncs[] = { + State_LoadApp, + State_EditingAlarm, + State_AlarmSet, + State_AlarmBlaring, + State_UnloadApp + }; + + PoketchAlarmClock *alarmClock = appData; + + if (alarmClock->state < NELEMS(stateFuncs)) { + PoketechSystem_UpdateButtonManager(alarmClock->poketchSys, alarmClock->buttonManager); + + if (stateFuncs[alarmClock->state](alarmClock)) { + Free(alarmClock); + SysTask_Done(task); + PoketchSystem_NotifyAppUnloaded(alarmClock->poketchSys); + } + } +} + +static void Exit(void *appData) +{ + ((PoketchAlarmClock *)appData)->shouldExit = TRUE; +} + +static void ChangeState(PoketchAlarmClock *appData, enum AlarmClockState newState) +{ + if (appData->shouldExit == FALSE) { + appData->state = newState; + } else { + appData->state = STATE_SHUTDOWN; + } + + appData->subState = 0; +} + +static BOOL State_LoadApp(PoketchAlarmClock *appData) +{ + switch (appData->subState) { + case 0: + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_INIT); + appData->subState++; + break; + case 1: + if (PoketchAlarmClockGraphics_TaskIsNotActive(appData->graphics, ALARM_CLOCK_GRAPHICS_INIT)) { + PoketchSystem_NotifyAppLoaded(appData->poketchSys); + + if (appData->clockData.alarmSet) { + ChangeState(appData, STATE_ALARM_SET); + } else { + ChangeState(appData, STATE_EDITING_ALARM); + } + } + break; + } + + return FALSE; +} + +static BOOL State_EditingAlarm(PoketchAlarmClock *appData) +{ + if (appData->shouldExit) { + ChangeState(appData, STATE_SHUTDOWN); + return FALSE; + } + + switch (appData->subState) { + case 0: + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH && appData->pressedButton == BUTTON_SET_ALARM) { + appData->clockData.alarmSet = TRUE; + InitCurrentTime(&appData->clockData); + Poketch_SetAlarm(appData->poketch, TRUE, appData->clockData.alarmHour, appData->clockData.alarmMinute); + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_SHOW_CURRENT_TIME); + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + appData->subState++; + break; + } + + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH && appData->pressedButton == BUTTON_EDIT_ALARM) { + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + PoketchSystem_PlaySoundEffect(SEQ_SE_DP_BEEP); + break; + } + + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH || appData->buttonState == BUTTON_MANAGER_STATE_REPEAT) { + switch (appData->pressedButton) { + case BUTTON_HOUR_UP: + if (++appData->clockData.alarmHour > 23) { + appData->clockData.alarmHour = 0; + } + break; + case BUTTON_HOUR_DOWN: + if (--appData->clockData.alarmHour < 0) { + appData->clockData.alarmHour = 23; + } + break; + case BUTTON_MINUTE_UP: + if (++appData->clockData.alarmMinute > 59) { + appData->clockData.alarmMinute = 0; + } + break; + case BUTTON_MINUTE_DOWN: + if (--appData->clockData.alarmMinute < 0) { + appData->clockData.alarmMinute = 59; + } + break; + } + + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS); + break; + } + break; + case 1: + if (PoketchAlarmClockGraphics_TaskIsNotActive(appData->graphics, ALARM_CLOCK_GRAPHICS_SHOW_CURRENT_TIME)) { + ChangeState(appData, STATE_ALARM_SET); + } + break; + } + + return FALSE; +} + +static BOOL State_AlarmSet(PoketchAlarmClock *appData) +{ + if (appData->shouldExit) { + ChangeState(appData, STATE_SHUTDOWN); + return FALSE; + } + + switch (appData->subState) { + case 0: + if (ActivateAlarm(&appData->clockData)) { + ChangeState(appData, STATE_ALARM_BLARING); + return FALSE; + } + + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH && appData->pressedButton == BUTTON_EDIT_ALARM) { + appData->clockData.alarmSet = FALSE; + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_ENTER_EDIT_MODE); + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + ChangeState(appData, STATE_EDITING_ALARM); + break; + } + + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH && appData->pressedButton == BUTTON_SET_ALARM) { + PoketchSystem_PlaySoundEffect(SEQ_SE_DP_BEEP); + break; + } + + if (AlwaysFalse(appData) == FALSE) { + UpdateCurrentTime(appData); + } + + u32 hour, minute; + + if (GetCurrentTime(appData, &hour, &minute)) { + if (minute != appData->clockData.currentMinute) { + appData->clockData.currentMinute = minute; + appData->clockData.currentHour = hour; + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS); + appData->subState++; + break; + } + } + break; + case 1: + if (PoketchAlarmClockGraphics_TaskIsNotActive(appData->graphics, ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS)) { + appData->subState = 0; + } + break; + } + + return FALSE; +} + +static BOOL State_AlarmBlaring(PoketchAlarmClock *appData) +{ + if (appData->shouldExit) { + ChangeState(appData, STATE_SHUTDOWN); + return FALSE; + } + + switch (appData->subState) { + case 0: + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_SOUND_ALARM); + appData->subState++; + break; + case 1: + if (ActivateAlarm(&appData->clockData) == FALSE) { + StopSoundingAlarm(appData->graphics); + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_SHOW_CURRENT_TIME); + ChangeState(appData, STATE_ALARM_SET); + return FALSE; + } + + if (appData->buttonState == BUTTON_MANAGER_STATE_TOUCH && appData->pressedButton == BUTTON_EDIT_ALARM) { + appData->clockData.alarmSet = FALSE; + StopSoundingAlarm(appData->graphics); + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_ENTER_EDIT_MODE); + appData->buttonState = BUTTON_MANAGER_STATE_NULL; + ChangeState(appData, STATE_EDITING_ALARM); + return FALSE; + } + + if (AlwaysFalse(appData) == FALSE) { + UpdateCurrentTime(appData); + } + + u32 hour, minute; + + if (GetCurrentTime(appData, &hour, &minute)) { + if (minute != appData->clockData.currentMinute) { + appData->clockData.currentMinute = minute; + appData->clockData.currentHour = hour; + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_UPDATE_DIGITS); + } + } + break; + } + + return FALSE; +} + +static BOOL AlwaysFalse(PoketchAlarmClock *appData) +{ + return appData->alwaysFalse; +} + +static void UpdateCurrentTime(PoketchAlarmClock *appData) +{ + if (appData->alwaysFalse == FALSE) { + RTC_GetCurrentTime(&appData->currentTime); + appData->currentTimeLoaded = TRUE; + } +} + +static BOOL GetCurrentTime(PoketchAlarmClock *appData, u32 *hour, u32 *minute) +{ + if (appData->currentTimeLoaded) { + *hour = appData->currentTime.hour; + *minute = appData->currentTime.minute; + return TRUE; + } + + return FALSE; +} + +static BOOL State_UnloadApp(PoketchAlarmClock *appData) +{ + switch (appData->subState) { + case 0: + PoketchAlarmClockGraphics_StartTask(appData->graphics, ALARM_CLOCK_GRAPHICS_FREE); + appData->subState++; + break; + case 1: + if (PoketchAlarmClockGraphics_NoActiveTasks(appData->graphics)) { + return TRUE; + } + break; + } + + return FALSE; +} + +static BOOL ActivateAlarm(AlarmClockData *clockData) +{ + return clockData->currentHour == clockData->alarmHour && clockData->currentMinute == clockData->alarmMinute; +} diff --git a/src/applications/poketch/analog_watch/main.c b/src/applications/poketch/analog_watch/main.c index a373815bfa..e6b4d7028d 100644 --- a/src/applications/poketch/analog_watch/main.c +++ b/src/applications/poketch/analog_watch/main.c @@ -85,7 +85,7 @@ static BOOL Init(PoketchAnalogWatch *appData, PoketchSystem *poketchSys, BgConfi appData->brightnessChangePending = FALSE; appData->watchData.isBright = FALSE; - GetCurrentTime(&appData->watchData.time); + RTC_GetCurrentTime(&appData->watchData.time); if (appData->watchData.time.hour >= 24) { appData->watchData.time.hour %= 24; @@ -201,7 +201,7 @@ static BOOL State_UpdateApp(PoketchAnalogWatch *appData) if (PoketchAnalogWatchGraphics_TaskIsNotActive(appData->graphics, ANALOG_WATCH_GRAPHICS_TIME)) { appData->lastUpdateMinute = appData->watchData.time.minute; - GetCurrentTime(&appData->watchData.time); + RTC_GetCurrentTime(&appData->watchData.time); if (appData->lastUpdateMinute != appData->watchData.time.minute) { PoketchAnalogWatchGraphics_StartTask(appData->graphics, ANALOG_WATCH_GRAPHICS_TIME); diff --git a/src/applications/poketch/digital_watch/main.c b/src/applications/poketch/digital_watch/main.c index 1577aa76fd..e1a2c8c013 100644 --- a/src/applications/poketch/digital_watch/main.c +++ b/src/applications/poketch/digital_watch/main.c @@ -87,7 +87,7 @@ static BOOL Init(PoketchDigitalWatch *appData, PoketchSystem *poketchSys, BgConf appData->backlightChange = FALSE; appData->watchData.backlightActive = FALSE; - GetCurrentTime(&appData->watchData.time); + RTC_GetCurrentTime(&appData->watchData.time); if (appData->watchData.time.hour >= 24) { appData->watchData.time.hour %= 24; @@ -206,7 +206,7 @@ static BOOL State_UpdateApp(PoketchDigitalWatch *appData) if (PoketchDigitalWatchGraphics_TaskIsNotActive(appData->graphics, DIGITAL_WATCH_GRAPHICS_UPDATE_DIGITS)) { appData->minute = appData->watchData.time.minute; appData->hour = appData->watchData.time.hour; - GetCurrentTime(&appData->watchData.time); + RTC_GetCurrentTime(&appData->watchData.time); if ((appData->minute != appData->watchData.time.minute) || (appData->hour != appData->watchData.time.hour)) { PoketchDigitalWatchGraphics_StartTask(appData->graphics, DIGITAL_WATCH_GRAPHICS_UPDATE_DIGITS); diff --git a/src/applications/poketch/poketch_system.c b/src/applications/poketch/poketch_system.c index 2c1d065339..fc06e1c7c0 100644 --- a/src/applications/poketch/poketch_system.c +++ b/src/applications/poketch/poketch_system.c @@ -45,7 +45,7 @@ FS_EXTERN_OVERLAY(poketch_roulette); FS_EXTERN_OVERLAY(overlay42); FS_EXTERN_OVERLAY(poketch_move_tester); FS_EXTERN_OVERLAY(overlay44); -FS_EXTERN_OVERLAY(overlay45); +FS_EXTERN_OVERLAY(poketch_alarm_clock); FS_EXTERN_OVERLAY(overlay46); FS_EXTERN_OVERLAY(overlay47); FS_EXTERN_OVERLAY(overlay48); @@ -100,7 +100,7 @@ static const struct { { POKETCH_APPID_COINTOSS, FS_OVERLAY_ID(overlay42) }, { POKETCH_APPID_MOVETESTER, FS_OVERLAY_ID(poketch_move_tester) }, { POKETCH_APPID_MATCHUPCHECKER, FS_OVERLAY_ID(overlay44) }, - { POKETCH_APPID_UNUSED_ALARMCLOCK, FS_OVERLAY_ID(overlay45) }, + { POKETCH_APPID_UNUSED_ALARMCLOCK, FS_OVERLAY_ID(poketch_alarm_clock) }, { POKETCH_APPID_KITCHENTIMER, FS_OVERLAY_ID(overlay46) }, { POKETCH_APPID_MARKINGMAP, FS_OVERLAY_ID(overlay47) }, { POKETCH_APPID_BERRYSEARCHER, FS_OVERLAY_ID(overlay48) }, diff --git a/src/game_opening/ov77_021D6C70.c b/src/game_opening/ov77_021D6C70.c index 6e80a1a9ab..e6dc96d5dc 100644 --- a/src/game_opening/ov77_021D6C70.c +++ b/src/game_opening/ov77_021D6C70.c @@ -113,7 +113,7 @@ void ov77_021D6CFC(UnkStruct_ov77_021D6CFC *param0) int v6, v7; RTCTime v8; - GetCurrentTime(&v8); + RTC_GetCurrentTime(&v8); v6 = (v8.hour * v8.minute + v8.second) & 1; v7 = v8.second % 3; diff --git a/src/meson.build b/src/meson.build index 6cc2cf7783..89c072b7c3 100644 --- a/src/meson.build +++ b/src/meson.build @@ -705,8 +705,8 @@ pokeplatinum_c = files( 'applications/poketch/move_tester/graphics.c', 'overlay044/ov44_022561C0.c', 'overlay044/ov44_022565BC.c', - 'overlay045/ov45_022561C0.c', - 'overlay045/ov45_022566EC.c', + 'applications/poketch/alarm_clock/main.c', + 'applications/poketch/alarm_clock/graphics.c', 'overlay046/ov46_022561C0.c', 'overlay046/ov46_02256BCC.c', 'overlay047/ov47_022561C0.c', diff --git a/src/overlay045/ov45_022561C0.c b/src/overlay045/ov45_022561C0.c deleted file mode 100644 index cb0fa073a6..0000000000 --- a/src/overlay045/ov45_022561C0.c +++ /dev/null @@ -1,463 +0,0 @@ -#include -#include -#include - -#include "applications/poketch/poketch_button.h" -#include "applications/poketch/poketch_system.h" -#include "overlay045/ov45_022566EC.h" -#include "overlay045/struct_ov45_022566EC_1.h" -#include "overlay045/struct_ov45_022566EC_decl.h" - -#include "bg_window.h" -#include "heap.h" -#include "poketch.h" -#include "rtc.h" -#include "sys_task.h" -#include "sys_task_manager.h" -#include "touch_screen.h" - -typedef struct { - u8 unk_00; - u8 unk_01; - u8 unk_02; - UnkStruct_ov45_022566EC_1 unk_03; - UnkStruct_ov45_022566EC *unk_08; - PoketchSystem *poketchSys; - Poketch *poketch; - PoketchButtonManager *buttonManager; - u32 unk_18; - u32 unk_1C; - RTCTime unk_20; - BOOL unk_2C; - BOOL unk_30; -} UnkStruct_ov45_022561D4; - -static void NitroStaticInit(void); - -static BOOL ov45_022561D4(void **param0, PoketchSystem *poketchSys, BgConfig *param2, u32 param3); -static BOOL ov45_0225621C(UnkStruct_ov45_022561D4 *param0, PoketchSystem *poketchSys, BgConfig *param2, u32 param3); -static void ov45_022562C0(UnkStruct_ov45_022566EC_1 *param0); -static void ov45_022562F8(UnkStruct_ov45_022561D4 *param0); -static void ov45_02256310(u32 param0, u32 param1, u32 param2, void *param3); -static void ov45_02256318(SysTask *param0, void *param1); -static void ov45_02256354(void *param0); -static void ov45_0225635C(UnkStruct_ov45_022561D4 *param0, u32 param1); -static BOOL ov45_02256370(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_022563C0(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_022564D0(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_0225659C(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_02256664(UnkStruct_ov45_022561D4 *param0); -static void ov45_02256668(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_02256680(UnkStruct_ov45_022561D4 *param0, u32 *param1, u32 *param2); -static BOOL ov45_02256698(UnkStruct_ov45_022561D4 *param0); -static BOOL ov45_022566CC(UnkStruct_ov45_022566EC_1 *param0); - -static void NitroStaticInit(void) -{ - PoketchSystem_SetAppFunctions(ov45_022561D4, ov45_02256354); -} - -static BOOL ov45_022561D4(void **param0, PoketchSystem *poketchSys, BgConfig *param2, u32 param3) -{ - UnkStruct_ov45_022561D4 *v0 = (UnkStruct_ov45_022561D4 *)Heap_Alloc(HEAP_ID_POKETCH_APP, sizeof(UnkStruct_ov45_022561D4)); - - if (v0 != NULL) { - if (ov45_0225621C(v0, poketchSys, param2, param3)) { - if (SysTask_Start(ov45_02256318, v0, 1) != NULL) { - *param0 = v0; - return 1; - } - } - - Heap_Free(v0); - } - - return 0; -} - -static BOOL ov45_0225621C(UnkStruct_ov45_022561D4 *param0, PoketchSystem *poketchSys, BgConfig *param2, u32 param3) -{ - static const TouchScreenHitTable v0[] = { - { - 72, - 104, - 176, - 208, - }, - { - 104, - 136, - 176, - 208, - }, - { - 112, - 128, - 64, - 80, - }, - { - 160, - 176, - 64, - 80, - }, - { - 112, - 128, - 112, - 128, - }, - { - 160, - 176, - 112, - 128, - } - }; - u32 v1, v2; - - param0->poketch = PoketchSystem_GetPoketchData(poketchSys); - param0->unk_03.unk_00 = Poketch_IsAlarmSet(param0->poketch); - - Poketch_AlarmTime(param0->poketch, &v1, &v2); - - param0->unk_03.unk_03 = v1; - param0->unk_03.unk_04 = v2; - - ov45_022562C0(¶m0->unk_03); - - if (ov45_022566EC(&(param0->unk_08), &(param0->unk_03), param2)) { - param0->unk_00 = 0; - param0->unk_01 = 0; - param0->unk_02 = 0; - param0->buttonManager = PoketchButtonManager_New(v0, NELEMS(v0), ov45_02256310, param0, HEAP_ID_POKETCH_APP); - param0->unk_1C = 0; - - PoketchButtonManager_SetRepeatTime(param0->buttonManager, 2, 4); - PoketchButtonManager_SetRepeatTime(param0->buttonManager, 3, 4); - PoketchButtonManager_SetRepeatTime(param0->buttonManager, 4, 4); - PoketchButtonManager_SetRepeatTime(param0->buttonManager, 5, 4); - - param0->unk_2C = 0; - param0->unk_30 = 0; - param0->poketchSys = poketchSys; - - return 1; - } - - return 0; -} - -static void ov45_022562C0(UnkStruct_ov45_022566EC_1 *param0) -{ - RTCTime v0; - - GetCurrentTime(&v0); - - if (v0.hour >= 24) { - v0.hour %= 24; - } - - if (v0.minute >= 60) { - v0.hour %= 60; - } - - param0->unk_01 = v0.hour; - param0->unk_02 = v0.minute; -} - -static void ov45_022562F8(UnkStruct_ov45_022561D4 *param0) -{ - PoketchButtonManager_Free(param0->buttonManager); - ov45_02256728(param0->unk_08); - - Heap_Free(param0); -} - -static void ov45_02256310(u32 param0, u32 param1, u32 param2, void *param3) -{ - UnkStruct_ov45_022561D4 *v0 = param3; - - v0->unk_18 = param0; - v0->unk_1C = param1; -} - -static void ov45_02256318(SysTask *param0, void *param1) -{ - static BOOL (*const v0[])(UnkStruct_ov45_022561D4 *) = { - ov45_02256370, - ov45_022563C0, - ov45_022564D0, - ov45_0225659C, - ov45_02256698 - }; - - UnkStruct_ov45_022561D4 *v1 = (UnkStruct_ov45_022561D4 *)param1; - - if (v1->unk_00 < NELEMS(v0)) { - PoketechSystem_UpdateButtonManager(v1->poketchSys, v1->buttonManager); - - if (v0[v1->unk_00](v1)) { - ov45_022562F8(v1); - SysTask_Done(param0); - PoketchSystem_NotifyAppUnloaded(v1->poketchSys); - } - } else { - } -} - -static void ov45_02256354(void *param0) -{ - ((UnkStruct_ov45_022561D4 *)param0)->unk_02 = 1; -} - -static void ov45_0225635C(UnkStruct_ov45_022561D4 *param0, u32 param1) -{ - if (param0->unk_02 == 0) { - param0->unk_00 = param1; - } else { - param0->unk_00 = 4; - } - - param0->unk_01 = 0; -} - -static BOOL ov45_02256370(UnkStruct_ov45_022561D4 *param0) -{ - switch (param0->unk_01) { - case 0: - ov45_02256918(param0->unk_08, 0); - param0->unk_01++; - break; - case 1: - if (ov45_0225693C(param0->unk_08, 0)) { - PoketchSystem_NotifyAppLoaded(param0->poketchSys); - - if (param0->unk_03.unk_00) { - ov45_0225635C(param0, 2); - } else { - ov45_0225635C(param0, 1); - } - } - break; - } - - return 0; -} - -static BOOL ov45_022563C0(UnkStruct_ov45_022561D4 *param0) -{ - if (param0->unk_02) { - ov45_0225635C(param0, 4); - return 0; - } - - switch (param0->unk_01) { - case 0: - if ((param0->unk_1C == 1) && (param0->unk_18 == 0)) { - param0->unk_03.unk_00 = 1; - ov45_022562C0(¶m0->unk_03); - Poketch_SetAlarm(param0->poketch, 1, param0->unk_03.unk_03, param0->unk_03.unk_04); - ov45_02256918(param0->unk_08, 2); - param0->unk_1C = 0; - param0->unk_01++; - break; - } - - if ((param0->unk_1C == 1) && (param0->unk_18 == 1)) { - param0->unk_1C = 0; - PoketchSystem_PlaySoundEffect(1646); - break; - } - - if ((param0->unk_1C == 1) || (param0->unk_1C == 7)) { - switch (param0->unk_18) { - case 2: - if (++(param0->unk_03.unk_03) > 23) { - param0->unk_03.unk_03 = 0; - } - break; - case 3: - if (--(param0->unk_03.unk_03) < 0) { - param0->unk_03.unk_03 = 23; - } - break; - case 4: - if (++(param0->unk_03.unk_04) > 59) { - param0->unk_03.unk_04 = 0; - } - break; - case 5: - if (--(param0->unk_03.unk_04) < 0) { - param0->unk_03.unk_04 = 59; - } - break; - } - - param0->unk_1C = 0; - ov45_02256918(param0->unk_08, 4); - break; - } - break; - case 1: - if (ov45_0225693C(param0->unk_08, 2)) { - ov45_0225635C(param0, 2); - } - break; - } - - return 0; -} - -static BOOL ov45_022564D0(UnkStruct_ov45_022561D4 *param0) -{ - if (param0->unk_02) { - ov45_0225635C(param0, 4); - return 0; - } - - switch (param0->unk_01) { - case 0: - if (ov45_022566CC(&(param0->unk_03))) { - ov45_0225635C(param0, 3); - return 0; - } - - if ((param0->unk_1C == 1) && (param0->unk_18 == 1)) { - param0->unk_03.unk_00 = 0; - ov45_02256918(param0->unk_08, 3); - param0->unk_1C = 0; - ov45_0225635C(param0, 1); - break; - } - - if ((param0->unk_1C == 1) && (param0->unk_18 == 0)) { - PoketchSystem_PlaySoundEffect(1646); - break; - } - - if (ov45_02256664(param0) == 0) { - ov45_02256668(param0); - } - - { - u32 v0, v1; - - if (ov45_02256680(param0, &v0, &v1)) { - if (v1 != param0->unk_03.unk_02) { - param0->unk_03.unk_02 = v1; - param0->unk_03.unk_01 = v0; - ov45_02256918(param0->unk_08, 4); - param0->unk_01++; - break; - } - } - } - break; - break; - case 1: - if (ov45_0225693C(param0->unk_08, 4)) { - param0->unk_01 = 0; - } - break; - } - - return 0; -} - -static BOOL ov45_0225659C(UnkStruct_ov45_022561D4 *param0) -{ - if (param0->unk_02) { - ov45_0225635C(param0, 4); - return 0; - } - - switch (param0->unk_01) { - case 0: - ov45_02256918(param0->unk_08, 5); - param0->unk_01++; - break; - case 1: - if (ov45_022566CC(&(param0->unk_03)) == 0) { - ov45_02256C90(param0->unk_08); - ov45_02256918(param0->unk_08, 2); - ov45_0225635C(param0, 2); - return 0; - } - - if ((param0->unk_1C == 1) && (param0->unk_18 == 1)) { - param0->unk_03.unk_00 = 0; - ov45_02256C90(param0->unk_08); - ov45_02256918(param0->unk_08, 3); - param0->unk_1C = 0; - ov45_0225635C(param0, 1); - return 0; - } - - if (ov45_02256664(param0) == 0) { - ov45_02256668(param0); - } - - { - u32 v0, v1; - - if (ov45_02256680(param0, &v0, &v1)) { - if (v1 != param0->unk_03.unk_02) { - param0->unk_03.unk_02 = v1; - param0->unk_03.unk_01 = v0; - ov45_02256918(param0->unk_08, 4); - } - } - } - break; - } - - return 0; -} - -static BOOL ov45_02256664(UnkStruct_ov45_022561D4 *param0) -{ - return param0->unk_2C; -} - -static void ov45_02256668(UnkStruct_ov45_022561D4 *param0) -{ - if (param0->unk_2C == 0) { - GetCurrentTime(&(param0->unk_20)); - param0->unk_30 = 1; - } -} - -static BOOL ov45_02256680(UnkStruct_ov45_022561D4 *param0, u32 *param1, u32 *param2) -{ - if (param0->unk_30) { - *param1 = param0->unk_20.hour; - *param2 = param0->unk_20.minute; - return 1; - } - - return 0; -} - -static BOOL ov45_02256698(UnkStruct_ov45_022561D4 *param0) -{ - switch (param0->unk_01) { - case 0: - ov45_02256918(param0->unk_08, 1); - param0->unk_01++; - break; - case 1: - if (ov45_02256948(param0->unk_08)) { - return 1; - } - break; - } - - return 0; -} - -static BOOL ov45_022566CC(UnkStruct_ov45_022566EC_1 *param0) -{ - return (param0->unk_01 == param0->unk_03) && (param0->unk_02 == param0->unk_04); -} diff --git a/src/overlay045/ov45_022566EC.c b/src/overlay045/ov45_022566EC.c deleted file mode 100644 index a4b84ad668..0000000000 --- a/src/overlay045/ov45_022566EC.c +++ /dev/null @@ -1,426 +0,0 @@ -#include "overlay045/ov45_022566EC.h" - -#include -#include - -#include "applications/poketch/poketch_animation.h" -#include "applications/poketch/poketch_graphics.h" -#include "applications/poketch/poketch_system.h" -#include "applications/poketch/poketch_task.h" -#include "overlay045/struct_ov45_022566EC_1.h" -#include "overlay045/struct_ov45_022566EC_decl.h" - -#include "bg_window.h" -#include "graphics.h" -#include "heap.h" -#include "sound_playback.h" -#include "sys_task_manager.h" - -struct UnkStruct_ov45_022566EC_t { - const UnkStruct_ov45_022566EC_1 *unk_00; - BgConfig *unk_04; - u32 unk_08[10]; - PoketchAnimation_AnimationManager *unk_30; - PoketchAnimation_AnimatedSpriteData *unk_34[13]; - PoketchAnimation_SpriteData unk_68; - PoketchAnimation_SpriteData unk_7C; - BOOL unk_90; - u32 unk_94; - u32 unk_98; -}; - -static void ov45_0225673C(UnkStruct_ov45_022566EC *param0, const UnkStruct_ov45_022566EC_1 *param1); -static void ov45_02256864(UnkStruct_ov45_022566EC *param0); -static void ov45_02256894(UnkStruct_ov45_022566EC *param0, u32 param1, u32 param2); -static void ov45_02256954(PoketchTaskManager *param0); -static void ov45_02256968(SysTask *param0, void *param1); -static void ov45_022569F8(SysTask *param0, void *param1); -static void ov45_02256A40(SysTask *param0, void *param1); -static void ov45_02256ABC(SysTask *param0, void *param1); -static void ov45_02256B38(SysTask *param0, void *param1); -static void ov45_02256B78(SysTask *param0, void *param1); - -BOOL ov45_022566EC(UnkStruct_ov45_022566EC **param0, const UnkStruct_ov45_022566EC_1 *param1, BgConfig *param2) -{ - UnkStruct_ov45_022566EC *v0 = (UnkStruct_ov45_022566EC *)Heap_Alloc(HEAP_ID_POKETCH_APP, sizeof(UnkStruct_ov45_022566EC)); - - if (v0 != NULL) { - PoketchTask_InitActiveTaskList(v0->unk_08, 8); - v0->unk_00 = param1; - v0->unk_04 = PoketchGraphics_GetBgConfig(); - v0->unk_30 = PoketchGraphics_GetAnimationManager(); - ov45_0225673C(v0, param1); - *param0 = v0; - return 1; - } - - return 0; -} - -void ov45_02256728(UnkStruct_ov45_022566EC *param0) -{ - if (param0 != NULL) { - ov45_02256864(param0); - Heap_Free(param0); - } -} - -static void ov45_0225673C(UnkStruct_ov45_022566EC *param0, const UnkStruct_ov45_022566EC_1 *param1) -{ - static const PoketchAnimation_AnimationData v0[] = { - { - { (192 << FX32_SHIFT), (104 << FX32_SHIFT) }, - 3, - 0, - 2, - 0, - 0, - }, - { - { (48 << FX32_SHIFT), (48 << FX32_SHIFT) }, - 0, - 0, - 2, - 0, - 0, - }, - { - { (144 << FX32_SHIFT), (48 << FX32_SHIFT) }, - 0, - 1, - 2, - 0, - 0, - }, - { - { (56 << FX32_SHIFT), (80 << FX32_SHIFT) }, - 4, - 0, - 2, - 0, - 0, - }, - { - { (136 << FX32_SHIFT), (80 << FX32_SHIFT) }, - 4, - 1, - 2, - 0, - 0, - }, - { - { (72 << FX32_SHIFT), (120 << FX32_SHIFT) }, - 6, - 0, - 2, - 0, - 0, - }, - { - { (72 << FX32_SHIFT), (164 << FX32_SHIFT) }, - 6, - 2, - 2, - 0, - 0, - }, - { - { (120 << FX32_SHIFT), (120 << FX32_SHIFT) }, - 6, - 0, - 2, - 0, - 0, - }, - { - { (120 << FX32_SHIFT), (164 << FX32_SHIFT) }, - 6, - 2, - 2, - 0, - 0, - }, - { - { (64 << FX32_SHIFT), (144 << FX32_SHIFT) }, - 0, - 0, - 2, - 0, - 0, - }, - { - { (80 << FX32_SHIFT), (144 << FX32_SHIFT) }, - 0, - 0, - 2, - 0, - 0, - }, - { - { (112 << FX32_SHIFT), (144 << FX32_SHIFT) }, - 0, - 0, - 2, - 0, - 0, - }, - { - { (128 << FX32_SHIFT), (144 << FX32_SHIFT) }, - 0, - 0, - 2, - 0, - 0, - }, - }; - int v1; - - Graphics_LoadObjectTiles(12, 2, 1, 0, 0, 1, HEAP_ID_POKETCH_APP); - Graphics_LoadObjectTiles(12, 79, 1, 80 * 0x20, 0, 1, HEAP_ID_POKETCH_APP); - - PoketchAnimation_LoadSpriteFromNARC(¶m0->unk_68, 12, 77, 78, 8); - PoketchAnimation_LoadSpriteFromNARC(¶m0->unk_7C, 12, 3, 4, 8); - - for (v1 = 0; v1 < 13; v1++) { - if ((v1 >= 9) && (v1 <= 12)) { - param0->unk_34[v1] = PoketchAnimation_SetupNewAnimatedSprite(param0->unk_30, &v0[v1], ¶m0->unk_7C); - } else { - param0->unk_34[v1] = PoketchAnimation_SetupNewAnimatedSprite(param0->unk_30, &v0[v1], ¶m0->unk_68); - PoketchAnimation_SetSpriteCharNo(param0->unk_34[v1], 80); - } - } - - if (param1->unk_00) { - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[0], 3); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[3], 5); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[4], 5); - PoketchAnimation_HideSprite(param0->unk_34[5], 1); - PoketchAnimation_HideSprite(param0->unk_34[6], 1); - PoketchAnimation_HideSprite(param0->unk_34[7], 1); - PoketchAnimation_HideSprite(param0->unk_34[8], 1); - ov45_02256894(param0, param1->unk_01, param1->unk_02); - } else { - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[0], 2); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[3], 5); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[4], 4); - ov45_02256894(param0, param1->unk_03, param1->unk_04); - } -} - -static void ov45_02256864(UnkStruct_ov45_022566EC *param0) -{ - int v0; - - for (v0 = 0; v0 < 13; v0++) { - if (param0->unk_34[v0]) { - PoketchAnimation_RemoveAnimatedSprite(param0->unk_30, param0->unk_34[v0]); - } - } - - PoketchAnimation_FreeSpriteData(¶m0->unk_68); - PoketchAnimation_FreeSpriteData(¶m0->unk_7C); -} - -static void ov45_02256894(UnkStruct_ov45_022566EC *param0, u32 param1, u32 param2) -{ - CP_SetDiv32_32(param1, 10); - - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[9], CP_GetDivResult32()); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[10], CP_GetDivRemainder32()); - - CP_SetDiv32_32(param2, 10); - - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[11], CP_GetDivResult32()); - PoketchAnimation_UpdateAnimationIdx(param0->unk_34[12], CP_GetDivRemainder32()); -} - -static const PoketchTask Unk_ov45_02256CE0[] = { - { 0x0, ov45_02256968, 0x0 }, - { 0x1, ov45_022569F8, 0x0 }, - { 0x2, ov45_02256A40, 0x0 }, - { 0x3, ov45_02256ABC, 0x0 }, - { 0x4, ov45_02256B38, 0x0 }, - { 0x5, ov45_02256B78, 0x0 }, - { 0x0, NULL, 0x0 } -}; - -void ov45_02256918(UnkStruct_ov45_022566EC *param0, u32 param1) -{ - PoketchTask_Start(Unk_ov45_02256CE0, param1, param0, param0->unk_00, param0->unk_08, 2, 8); -} - -BOOL ov45_0225693C(UnkStruct_ov45_022566EC *param0, u32 param1) -{ - return PoketchTask_TaskIsNotActive(param0->unk_08, param1); -} - -BOOL ov45_02256948(UnkStruct_ov45_022566EC *param0) -{ - return PoketchTask_NoActiveTasks(param0->unk_08); -} - -static void ov45_02256954(PoketchTaskManager *param0) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param0); - PoketchTask_EndTask(v0->unk_08, param0); -} - -static void ov45_02256968(SysTask *param0, void *param1) -{ - static const BgTemplate v0 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0x7000, - .charBase = GX_BG_CHARBASE_0x00000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 2, - .areaOver = 0, - .mosaic = FALSE, - }; - GXSDispCnt v1; - UnkStruct_ov45_022566EC *v2; - void *v3; - NNSG2dPaletteData *v4; - - v2 = PoketchTask_GetTaskData(param1); - - Bg_InitFromTemplate(v2->unk_04, BG_LAYER_SUB_2, &v0, 0); - Graphics_LoadTilesToBgLayer(NARC_INDEX_GRAPHIC__POKETCH, 76, v2->unk_04, BG_LAYER_SUB_2, 0, 0, 1, HEAP_ID_POKETCH_APP); - Graphics_LoadTilemapToBgLayer(NARC_INDEX_GRAPHIC__POKETCH, 75, v2->unk_04, BG_LAYER_SUB_2, 0, 0, 1, HEAP_ID_POKETCH_APP); - - PoketchGraphics_LoadActivePalette(0, 0); - Bg_CopyTilemapBufferToVRAM(v2->unk_04, 6); - - v1 = GXS_GetDispCnt(); - GXS_SetVisiblePlane(v1.visiblePlane | GX_PLANEMASK_BG2); - - ov45_02256954(param1); -} - -static void ov45_022569F8(SysTask *param0, void *param1) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param1); - - switch (PoketchTask_GetState(param1)) { - case 0: - ov45_02256C90(v0); - PoketchTask_IncrementState(param1); - break; - case 1: - if (ov45_0225693C(v0, 5)) { - Bg_FreeTilemapBuffer(v0->unk_04, BG_LAYER_SUB_2); - ov45_02256954(param1); - } - break; - } -} - -static void ov45_02256A40(SysTask *param0, void *param1) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param1); - const UnkStruct_ov45_022566EC_1 *v1 = PoketchTask_GetConstTaskData(param1); - - PoketchSystem_PlaySoundEffect(1635); - - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[0], 3); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[3], 5); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[4], 5); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[1], 0); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[2], 0); - PoketchAnimation_HideSprite(v0->unk_34[5], 1); - PoketchAnimation_HideSprite(v0->unk_34[6], 1); - PoketchAnimation_HideSprite(v0->unk_34[7], 1); - PoketchAnimation_HideSprite(v0->unk_34[8], 1); - ov45_02256894(v0, v1->unk_01, v1->unk_02); - - ov45_02256954(param1); -} - -static void ov45_02256ABC(SysTask *param0, void *param1) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param1); - const UnkStruct_ov45_022566EC_1 *v1 = PoketchTask_GetConstTaskData(param1); - - PoketchSystem_PlaySoundEffect(1635); - - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[0], 2); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[3], 5); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[4], 4); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[1], 0); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[2], 0); - PoketchAnimation_HideSprite(v0->unk_34[5], 0); - PoketchAnimation_HideSprite(v0->unk_34[6], 0); - PoketchAnimation_HideSprite(v0->unk_34[7], 0); - PoketchAnimation_HideSprite(v0->unk_34[8], 0); - ov45_02256894(v0, v1->unk_03, v1->unk_04); - - ov45_02256954(param1); -} - -static void ov45_02256B38(SysTask *param0, void *param1) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param1); - const UnkStruct_ov45_022566EC_1 *v1 = PoketchTask_GetConstTaskData(param1); - - if (v1->unk_00) { - ov45_02256894(v0, v1->unk_01, v1->unk_02); - } else { - ov45_02256894(v0, v1->unk_03, v1->unk_04); - } - - ov45_02256954(param1); -} - -static void ov45_02256B78(SysTask *param0, void *param1) -{ - UnkStruct_ov45_022566EC *v0 = PoketchTask_GetTaskData(param1); - const UnkStruct_ov45_022566EC_1 *v1 = PoketchTask_GetConstTaskData(param1); - - switch (PoketchTask_GetState(param1)) { - case 0: - v0->unk_90 = 0; - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[3], 4); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[4], 4); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[1], 1); - PoketchAnimation_UpdateAnimationIdx(v0->unk_34[2], 1); - PoketchSystem_PlaySoundEffect(1635); - PoketchSystem_PlayCry(294, 0); - v0->unk_94 = 0; - v0->unk_98 = 0; - PoketchTask_IncrementState(param1); - break; - case 1: - if (v0->unk_90) { - PoketchAnimation_HideSprite(v0->unk_34[9], 0); - PoketchAnimation_HideSprite(v0->unk_34[10], 0); - PoketchAnimation_HideSprite(v0->unk_34[11], 0); - PoketchAnimation_HideSprite(v0->unk_34[12], 0); - ov45_02256954(param1); - return; - } - - if (Sound_IsPokemonCryPlaying() == 0) { - PoketchSystem_PlayCry(294, 0); - } - - if (++(v0->unk_94) >= 15) { - v0->unk_94 = 0; - v0->unk_98 ^= 1; - - PoketchAnimation_HideSprite(v0->unk_34[9], v0->unk_98); - PoketchAnimation_HideSprite(v0->unk_34[10], v0->unk_98); - PoketchAnimation_HideSprite(v0->unk_34[11], v0->unk_98); - PoketchAnimation_HideSprite(v0->unk_34[12], v0->unk_98); - } - break; - } -} - -void ov45_02256C90(UnkStruct_ov45_022566EC *param0) -{ - param0->unk_90 = 1; -} diff --git a/src/pokemon.c b/src/pokemon.c index 4afa4f8e89..ce0bc33e54 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -4459,7 +4459,7 @@ BOOL Pokemon_CanShayminSkyForm(Pokemon *mon) u32 fatefulEncounter = Pokemon_GetValue(mon, MON_DATA_FATEFUL_ENCOUNTER, NULL); RTCTime rtcTime; - GetCurrentTime(&rtcTime); + RTC_GetCurrentTime(&rtcTime); return species == SPECIES_SHAYMIN && monForm == SHAYMIN_FORM_LAND diff --git a/src/rtc.c b/src/rtc.c index 430489d9cb..1610a0c88b 100644 --- a/src/rtc.c +++ b/src/rtc.c @@ -75,7 +75,7 @@ void GetCurrentDateTime(RTCDate *date, RTCTime *time) *time = sRTCState.time; } -void GetCurrentTime(RTCTime *time) +void RTC_GetCurrentTime(RTCTime *time) { GF_ASSERT(sRTCState.valid == 1); *time = sRTCState.time; @@ -146,7 +146,7 @@ enum TimeOfDay GetTimeOfDay(void) { RTCTime time; - GetCurrentTime(&time); + RTC_GetCurrentTime(&time); return TimeOfDayForHour(time.hour); }