Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-10-02 06:20:38 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Document Poketch Alarm Clock (Overlay 45) (#795)

Browse Source
This commit is contained in:
VicSevenT
2025-10-11 15:55:35 -05:00
committed by GitHub
parent 73dc9a1e91
commit b03a102605
18 changed files with 929 additions and 940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
include/applications/poketch/alarm_clock/graphics.h Normal file
View File

@@ -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

16
include/overlay045/ov45_022566EC.h
View File

@@ -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

12
include/overlay045/struct_ov45_022566EC_1.h
View File

@@ -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

6
include/overlay045/struct_ov45_022566EC_decl.h
View File

@@ -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

2
include/rtc.h
View File

@@ -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);

6
platinum.us/main.lsf
View File

@@ -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

2
platinum.us/sbins_shared.sha1
View File

@@ -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

417
src/applications/poketch/alarm_clock/graphics.c Normal file
View File

@@ -0,0 +1,417 @@
#include "applications/poketch/alarm_clock/graphics.h"
#include <nitro.h>
#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;
}

445
src/applications/poketch/alarm_clock/main.c Normal file
View File

@@ -0,0 +1,445 @@
#include <nitro.h>
#include <nitro/sinit.h>
#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;
}

4
src/applications/poketch/analog_watch/main.c
View File

@@ -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);

4
src/applications/poketch/digital_watch/main.c
View File

@@ -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);

4
src/applications/poketch/poketch_system.c
View File

@@ -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) },

2
src/game_opening/ov77_021D6C70.c
View File

@@ -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;

4
src/meson.build
View File

@@ -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',

463
src/overlay045/ov45_022561C0.c
View File

@@ -1,463 +0,0 @@
#include <nitro.h>
#include <nitro/sinit.h>
#include <string.h>
#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(&param0->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(&param0->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);
}

426
src/overlay045/ov45_022566EC.c
View File

@@ -1,426 +0,0 @@
#include "overlay045/ov45_022566EC.h"
#include <nitro.h>
#include <string.h>
#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(&param0->unk_68, 12, 77, 78, 8);
PoketchAnimation_LoadSpriteFromNARC(&param0->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], &param0->unk_7C);
} else {
param0->unk_34[v1] = PoketchAnimation_SetupNewAnimatedSprite(param0->unk_30, &v0[v1], &param0->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(&param0->unk_68);
PoketchAnimation_FreeSpriteData(&param0->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;
}

2
src/pokemon.c
View File

@@ -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

4
src/rtc.c
View File

@@ -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);
}