mirror of
https://github.com/ACreTeam/ac-decomp
synced 2026-05-29 16:14:59 -04:00
Cuyler36
820 lines
19 KiB
C
820 lines
19 KiB
C
#include "m_event.h"
|
|
|
|
#include "libultra/libultra.h"
|
|
#include "m_common_data.h"
|
|
#include "ac_aprilfool_control_h.h"
|
|
#include "m_play.h"
|
|
#include "m_scene_table.h"
|
|
|
|
static int n_today_events;
|
|
static int status_edge;
|
|
static int funeral;
|
|
static int dead;
|
|
static lbRTC_year_t weekday1st_year;
|
|
static lbRTC_weekday_t weekday1st[lbRTC_MONTHS_MAX];
|
|
|
|
extern void mEv_ClearSpecialEvent(mEv_special_c* special_event) {
|
|
special_event->type = -1;
|
|
bzero(&special_event->event, sizeof(mEv_special_u));
|
|
bzero(Common_GetPointer(event_common), sizeof(mEv_event_common_u));
|
|
}
|
|
|
|
extern void mEv_ClearEventKabuPeddler(mEv_kabu_peddler_c* kabu_peddler) {
|
|
if (kabu_peddler != NULL) {
|
|
mPr_ClearAnyPersonalID(kabu_peddler->spoken_pids, TOTAL_PLAYER_NUM);
|
|
}
|
|
}
|
|
|
|
extern void mEv_ClearEventSaveInfo(mEv_event_save_c* save_event) {
|
|
mEv_ClearSpecialEvent(&save_event->special);
|
|
mEv_ClearEventKabuPeddler(&save_event->weekly.kabu_peddler);
|
|
save_event->flags = 0;
|
|
}
|
|
|
|
extern void mEv_ClearEventInfo() {
|
|
u32* event_flag = Common_Get(event_flags);
|
|
int i;
|
|
|
|
for (i = 0; i < mEv_EVENT_TYPE_NUM; i++) {
|
|
event_flag[0] = 0;
|
|
event_flag++;
|
|
}
|
|
|
|
Common_Set(event_flags[1], Save_Get(event_save_data.flags));
|
|
Common_Get(event_common).fieldday_event_id = -1;
|
|
Common_Get(event_common).fieldday_event_over_status = -1;
|
|
}
|
|
|
|
extern void mEv_EventON(u32 event_kind) {
|
|
int type = mEv_GET_TYPE(event_kind);
|
|
u32 flag;
|
|
|
|
if (type >= mEv_EVENT_TYPE_NUM) {
|
|
return;
|
|
}
|
|
|
|
flag = Common_Get(event_flags[type]);
|
|
flag |= (1 << mEv_GET_SUBTYPE(event_kind));
|
|
Common_Set(event_flags[type], flag);
|
|
|
|
if (type != mEv_SAVED_EVENT) {
|
|
return;
|
|
}
|
|
|
|
Save_Get(event_save_data).flags = Common_Get(event_flags[flag]);
|
|
}
|
|
|
|
extern void mEv_EventOFF(u32 event_kind) {
|
|
int type = mEv_GET_TYPE(event_kind);
|
|
u32 flag;
|
|
|
|
if (type >= mEv_EVENT_TYPE_NUM) {
|
|
return;
|
|
}
|
|
|
|
flag = Common_Get(event_flags[type]);
|
|
flag &= ~(1 << mEv_GET_SUBTYPE(event_kind));
|
|
Common_Set(event_flags[type], flag);
|
|
|
|
if (type != mEv_SAVED_EVENT) {
|
|
return;
|
|
}
|
|
|
|
Save_Get(event_save_data).flags = Common_Get(event_flags[flag]);
|
|
}
|
|
|
|
extern int mEv_CheckEvent(u32 event_kind) {
|
|
int type = mEv_GET_TYPE(event_kind);
|
|
int res = FALSE;
|
|
|
|
if (type < mEv_EVENT_TYPE_NUM && ((Common_Get(event_flags[type]) >> mEv_GET_SUBTYPE(event_kind)) & 1)) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern void mEv_ClearPersonalEventFlag(int player_no) {
|
|
mEv_EventOFF(mEv_SAVED_FIRSTJOB_PLR0 + player_no);
|
|
mEv_EventOFF(mEv_SAVED_FIRSTINTRO_PLR0 + player_no);
|
|
mEv_EventOFF(mEv_SAVED_HRAWAIT_PLR0 + player_no);
|
|
mEv_EventOFF(mEv_SAVED_HRATALK_PLR0 + player_no);
|
|
mEv_EventOFF(mEv_SAVED_FJOPENQUEST_PLR0 + player_no);
|
|
mEv_EventOFF(mEv_SAVED_GATEWAY_PLR0 + player_no);
|
|
|
|
{
|
|
aAPC_event_save_data_c* data = (aAPC_event_save_data_c*)mEv_get_save_area(mEv_EVENT_APRILFOOLS_DAY, 0);
|
|
|
|
if (data != NULL) {
|
|
data->talk_bitfield[player_no] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern void mEv_SetFirstJob() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < PLAYER_NUM) {
|
|
mEv_EventON(mEv_SAVED_FIRSTJOB_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
extern int mEv_CheckRealArbeit() {
|
|
int player_no = Common_Get(player_no);
|
|
int res = FALSE;
|
|
|
|
if (
|
|
player_no < PLAYER_NUM &&
|
|
(
|
|
mEv_CheckEvent(mEv_SAVED_FIRSTJOB_PLR0 + player_no) == TRUE ||
|
|
mEv_CheckEvent( mEv_SAVED_HRAWAIT_PLR0 + player_no) == TRUE
|
|
)
|
|
) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern int mEv_CheckArbeit() {
|
|
int player_no = Common_Get(player_no);
|
|
int res = FALSE;
|
|
|
|
if (
|
|
player_no < PLAYER_NUM &&
|
|
(
|
|
mEv_CheckEvent(mEv_SAVED_FIRSTJOB_PLR0 + player_no) == TRUE ||
|
|
mEv_CheckEvent( mEv_SAVED_HRAWAIT_PLR0 + player_no) == TRUE ||
|
|
mEv_CheckEvent( mEv_SAVED_HRATALK_PLR0 + player_no) == TRUE
|
|
)
|
|
) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern int mFI_CheckFirstJob() {
|
|
int player_no = Common_Get(player_no);
|
|
int res = FALSE;
|
|
|
|
if (
|
|
player_no < PLAYER_NUM &&
|
|
mEv_CheckEvent(mEv_SAVED_FIRSTJOB_PLR0 + player_no) == TRUE
|
|
) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern void mEv_UnSetFirstJob() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < PLAYER_NUM) {
|
|
mEv_EventOFF(mEv_SAVED_FIRSTJOB_PLR0 + player_no);
|
|
mEv_EventON(mEv_SAVED_HRAWAIT_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
extern void mEv_SetFirstIntro() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < PLAYER_NUM) {
|
|
mEv_EventON(mEv_SAVED_FIRSTINTRO_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
extern int mEv_CheckFirstIntro() {
|
|
int player_no = Common_Get(player_no);
|
|
int res = FALSE;
|
|
|
|
if (
|
|
player_no < PLAYER_NUM &&
|
|
mEv_CheckEvent(mEv_SAVED_FIRSTINTRO_PLR0 + player_no) == TRUE
|
|
) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern void mEv_UnSetFirstIntro() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < PLAYER_NUM) {
|
|
mEv_EventOFF(mEv_SAVED_FIRSTINTRO_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
extern void mEv_SetGateway() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < TOTAL_PLAYER_NUM) {
|
|
mEv_EventON(mEv_SAVED_GATEWAY_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
extern int mEv_CheckGateway() {
|
|
int player_no = Common_Get(player_no);
|
|
int res = FALSE;
|
|
|
|
if (
|
|
player_no < TOTAL_PLAYER_NUM &&
|
|
mEv_CheckEvent(mEv_SAVED_GATEWAY_PLR0 + player_no) == TRUE
|
|
) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
extern void mEv_UnSetGateway() {
|
|
int player_no = Common_Get(player_no);
|
|
|
|
if (player_no < TOTAL_PLAYER_NUM) {
|
|
mEv_EventOFF(mEv_SAVED_GATEWAY_PLR0 + player_no);
|
|
}
|
|
}
|
|
|
|
static int title_demo_number = -1;
|
|
|
|
extern int mEv_CheckTitleDemo() {
|
|
return title_demo_number;
|
|
}
|
|
|
|
extern void mEv_SetTitleDemo(int demo_number) {
|
|
title_demo_number = demo_number;
|
|
}
|
|
|
|
extern void mEv_RenewalDataEveryDay() {
|
|
if (mTM_check_renew_time(mTM_RENEW_TIME_DAILY) == TRUE) {
|
|
int i;
|
|
|
|
for (i = 0; i < PLAYER_NUM; i++) {
|
|
if (mEv_CheckEvent(mEv_SAVED_HRAWAIT_PLR0 + i) == TRUE) {
|
|
/* After a new day starts, turn off all players' 'wait a day' HRA event and turn on talk to Tom Nook HRA event */
|
|
mEv_EventOFF(mEv_SAVED_HRAWAIT_PLR0 + i);
|
|
mEv_EventON(mEv_SAVED_HRATALK_PLR0 + i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern void mEv_GetEventWeather(s16* weather, s16* intensity) {
|
|
intensity[0] = mEnv_WEATHER_INTENSITY_HEAVY;
|
|
|
|
if (mEv_check_schedule(mEv_EVENT_WEATHER_CLEAR)) {
|
|
weather[0] = mEnv_WEATHER_CLEAR;
|
|
}
|
|
else if (mEv_check_schedule(mEv_EVENT_WEATHER_SNOW)) {
|
|
weather[0] = mEnv_WEATHER_SNOW;
|
|
}
|
|
else if (mEv_check_schedule(mEv_EVENT_WEATHER_SPORTS_FAIR)) {
|
|
weather[0] = mEnv_WEATHER_CLEAR;
|
|
}
|
|
else {
|
|
weather[0] = -1; // no event weather
|
|
}
|
|
}
|
|
|
|
static lbRTC_day_t last_day_of_month(lbRTC_month_t month) {
|
|
static lbRTC_day_t last_day[lbRTC_MONTHS_MAX] = {
|
|
31, 28, 31, 30,
|
|
31, 30, 31, 31,
|
|
30, 31, 30, 31
|
|
};
|
|
|
|
lbRTC_time_c* rtc_time = Common_GetPointer(time.rtc_time);
|
|
lbRTC_year_t year = rtc_time->year;
|
|
|
|
if (month != lbRTC_FEBRUARY) {
|
|
return last_day[month - 1];
|
|
}
|
|
else if (lbRTC_IS_LEAPYEAR(year)) {
|
|
return 29;
|
|
}
|
|
else {
|
|
return 28;
|
|
}
|
|
}
|
|
|
|
static void init_weekday1st() {
|
|
lbRTC_time_c* rtc_time = Common_GetPointer(time.rtc_time);
|
|
lbRTC_month_t month = rtc_time->month & 0xF; // ??
|
|
lbRTC_month_t i;
|
|
lbRTC_weekday_t weekday;
|
|
|
|
weekday1st_year = rtc_time->year;
|
|
|
|
weekday = (rtc_time->weekday + (1 - rtc_time->day)) % lbRTC_WEEK;
|
|
if (weekday < 0) {
|
|
weekday += lbRTC_WEEK;
|
|
}
|
|
|
|
weekday1st[month] = weekday;
|
|
|
|
for (i = month + 1; i <= lbRTC_MONTHS_MAX; i++) {
|
|
weekday1st[i] = (weekday1st[i - 1] + last_day_of_month(i)) % lbRTC_WEEK;
|
|
}
|
|
|
|
for (i = month - 1; i >= lbRTC_JANUARY; i--) {
|
|
weekday = (weekday1st[i + 1] - last_day_of_month(i)) % lbRTC_WEEK;
|
|
if (weekday < 0) {
|
|
weekday += lbRTC_WEEK;
|
|
}
|
|
|
|
weekday1st[i] = weekday;
|
|
}
|
|
}
|
|
|
|
static int check_date_range(u16 date, u16 lower_bound, u16 upper_bound) {
|
|
if (upper_bound < lower_bound) {
|
|
if (date < lower_bound && date > upper_bound) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (date < lower_bound || date > upper_bound) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
static int check_ymdh_range(u32 ymdh, u32 lower_bound, u32 upper_bound) {
|
|
int res = FALSE;
|
|
|
|
if (ymdh >= lower_bound && ymdh <= upper_bound) {
|
|
res = TRUE;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static mEv_MonthDay_u after_n_day(mEv_MonthDay_u month_day, int n_day) {
|
|
mEv_MonthDay_u after = month_day;
|
|
|
|
if (n_day >= 0) {
|
|
lbRTC_day_t last_day = last_day_of_month(after.month);
|
|
|
|
after.day = after.day + n_day;
|
|
if (after.day > last_day) {
|
|
if (after.month == lbRTC_DECEMBER) {
|
|
after.month = lbRTC_JANUARY;
|
|
}
|
|
else {
|
|
after.month++;
|
|
}
|
|
|
|
after.day -= last_day;
|
|
}
|
|
}
|
|
else {
|
|
after.day = after.day + n_day;
|
|
if ((after.day & 0x80) != 0 || after.day == 0) {
|
|
if (after.month == lbRTC_JANUARY) {
|
|
after.month = lbRTC_DECEMBER;
|
|
}
|
|
else {
|
|
after.month--;
|
|
}
|
|
|
|
after.day += last_day_of_month(after.month);
|
|
}
|
|
}
|
|
|
|
return after;
|
|
}
|
|
|
|
extern lbRTC_day_t mEv_get_next_weekday(lbRTC_weekday_t weekday) {
|
|
lbRTC_weekday_t next_weekday;
|
|
lbRTC_day_t day;
|
|
lbRTC_day_t last_day;
|
|
|
|
if (weekday >= Common_Get(time.rtc_time).weekday) {
|
|
next_weekday = weekday - Common_Get(time.rtc_time).weekday;
|
|
}
|
|
else {
|
|
next_weekday = lbRTC_WEEK - (Common_Get(time.rtc_time).weekday - weekday);
|
|
}
|
|
|
|
day = Common_Get(time.rtc_time).day + next_weekday;
|
|
last_day = last_day_of_month(Common_Get(time.rtc_time).month);
|
|
|
|
if (day > last_day) {
|
|
day -= last_day;
|
|
}
|
|
|
|
return day;
|
|
}
|
|
|
|
#define mEv_date_decode_weekday(day) ((day) & 0b00000111) // 0-6 (which weekday, Sunday-Saturday)
|
|
#define mEv_date_decode_week(day) (((day) & 0b00111000) >> 3) // 0-5 (which week of the month, 1st, 2nd, 3rd, ...)
|
|
|
|
static lbRTC_day_t m_weekday2day(lbRTC_month_t month, u8 day_enc) {
|
|
int week = mEv_date_decode_week(day_enc); // get the week of the month
|
|
int weekday = mEv_date_decode_weekday(day_enc); // get the weekday
|
|
lbRTC_day_t day = 0;
|
|
lbRTC_day_t last_day = last_day_of_month(month);
|
|
|
|
if (week == mEv_SCHEDULE_WEEKLY) {
|
|
if (month > Common_Get(time.rtc_time).month) {
|
|
week = 1; /* 1st week of this month */
|
|
}
|
|
else if (month < Common_Get(time.rtc_time).month) {
|
|
week = mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH; /* last weekday of the month */
|
|
}
|
|
else {
|
|
day = Common_Get(time.rtc_time).day - (Common_Get(time.rtc_time).weekday - weekday);
|
|
|
|
if (day > last_day) {
|
|
week = mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH;
|
|
}
|
|
else {
|
|
week = 0; /* cleared */
|
|
}
|
|
}
|
|
}
|
|
|
|
if (week == mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH) {
|
|
int t_day = (last_day + weekday1st[month] - 1) % lbRTC_WEEK; /* get the weekday of the first day of next month */
|
|
|
|
if (t_day < weekday) {
|
|
day = (last_day - (t_day - weekday)) - lbRTC_WEEK;
|
|
}
|
|
else {
|
|
day = last_day - (t_day - weekday);
|
|
}
|
|
}
|
|
else if (week != 0) {
|
|
int t_day = weekday1st[month];
|
|
|
|
if (weekday < t_day) {
|
|
day = week * lbRTC_WEEK + (weekday - t_day) + 1;
|
|
}
|
|
else {
|
|
day = (week - 1) * lbRTC_WEEK + (weekday - t_day) + 1;
|
|
}
|
|
}
|
|
|
|
return day;
|
|
}
|
|
|
|
extern lbRTC_day_t mEv_weeday2day(lbRTC_month_t month, int week, int weekday) {
|
|
lbRTC_day_t day = 0;
|
|
lbRTC_day_t last_day = last_day_of_month(month);
|
|
|
|
if (week == mEv_SCHEDULE_WEEKLY) {
|
|
if (month > Common_Get(time.rtc_time).month) {
|
|
week = 1; /* 1st week of this month */
|
|
}
|
|
else if (month < Common_Get(time.rtc_time).month) {
|
|
week = mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH; /* last weekday of the month */
|
|
}
|
|
else {
|
|
day = Common_Get(time.rtc_time).day - (Common_Get(time.rtc_time).weekday - weekday);
|
|
|
|
if (day > last_day) {
|
|
week = mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH;
|
|
}
|
|
else {
|
|
week = 0; /* cleared */
|
|
}
|
|
}
|
|
}
|
|
|
|
if (week == mEv_SCHEDULE_LAST_WEEKDAY_OF_MONTH) {
|
|
int t_day = (last_day + weekday1st[month] - 1) % lbRTC_WEEK; /* get the weekday of the first day of next month */
|
|
|
|
if (t_day < weekday) {
|
|
day = (last_day - (t_day - weekday)) - lbRTC_WEEK;
|
|
}
|
|
else {
|
|
day = last_day - (t_day - weekday);
|
|
}
|
|
}
|
|
else if (week != 0) {
|
|
int t_day = weekday1st[month];
|
|
|
|
if (weekday < t_day) {
|
|
day = week * lbRTC_WEEK + (weekday - t_day) + 1;
|
|
}
|
|
else {
|
|
day = (week - 1) * lbRTC_WEEK + (weekday - t_day) + 1;
|
|
}
|
|
}
|
|
|
|
return day;
|
|
}
|
|
|
|
static int get_end_time(u32 active_hours) {
|
|
int hour;
|
|
int i;
|
|
|
|
if (active_hours & ((1 << 24) - 1) == 0) {
|
|
return -1; /* no active hours */
|
|
}
|
|
|
|
hour = 23;
|
|
for (i = 0; i < 24; i++) {
|
|
if ((active_hours & (1 << 23)) & 1) {
|
|
break;
|
|
}
|
|
|
|
active_hours <<= 1; /* move hours left by one bit, MSB is latest hour */
|
|
hour--;
|
|
}
|
|
|
|
return hour;
|
|
}
|
|
|
|
static mEv_event_today_c event_today[mEv_TODAY_EVENT_NUM];
|
|
static u8 index_today[mEv_EVENT_NUM];
|
|
|
|
extern int mEv_get_end_time(int event_type) {
|
|
u8 idx = index_today[event_type];
|
|
|
|
if (idx == 0xFF) {
|
|
return -1;
|
|
}
|
|
else {
|
|
return get_end_time(event_today[idx].active_hours);
|
|
}
|
|
}
|
|
|
|
static int search_empty_event_today() {
|
|
int i;
|
|
|
|
for (i = 0; i < mEv_TODAY_EVENT_NUM; i++) {
|
|
if (event_today[i].type == -1) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
static int add_event_today(mEv_MonthDay_u month_day, mEv_schedule_c* schedule) {
|
|
u8 idx = index_today[schedule->type];
|
|
int res = FALSE;
|
|
|
|
if (idx == 0xFF) {
|
|
idx = search_empty_event_today();
|
|
|
|
if (idx >= mEv_TODAY_EVENT_NUM) {
|
|
return FALSE;
|
|
}
|
|
|
|
n_today_events++;
|
|
index_today[schedule->type] = idx;
|
|
}
|
|
|
|
{
|
|
u8 start_hour = schedule->date[0].hour;
|
|
u8 end_hour = schedule->date[1].hour;
|
|
u32 i;
|
|
u32 n;
|
|
|
|
if ((start_hour & mEv_SCHEDULE_TODAY) == 0) {
|
|
event_today[idx].begin_date = schedule->date[0].month_day;
|
|
event_today[idx].end_date = schedule->date[1].month_day;
|
|
}
|
|
else {
|
|
event_today[idx].begin_date = month_day;
|
|
event_today[idx].end_date = month_day;
|
|
start_hour &= ~mEv_SCHEDULE_TODAY;
|
|
end_hour &= ~mEv_SCHEDULE_TODAY;
|
|
}
|
|
|
|
if ((start_hour & mEv_SCHEDULE_MULTIDAY) != 0) {
|
|
start_hour &= ~mEv_SCHEDULE_MULTIDAY;
|
|
end_hour &= ~mEv_SCHEDULE_MULTIDAY;
|
|
|
|
if (month_day.raw != schedule->date[0].month_day.raw) {
|
|
start_hour = 0;
|
|
}
|
|
|
|
if (month_day.raw != schedule->date[1].month_day.raw) {
|
|
end_hour = 23;
|
|
}
|
|
}
|
|
|
|
n = 1;
|
|
for (i = 0; i < 24; i++) {
|
|
if (i >= start_hour && i <= end_hour) {
|
|
event_today[idx].active_hours |= n;
|
|
}
|
|
|
|
n <<= 1;
|
|
}
|
|
|
|
event_today[idx].type = schedule->type;
|
|
event_today[idx].status |= mEv_STATUS_EXIST;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int check_and_clear_event_today(Event_c* event, int type) {
|
|
u8 idx = index_today[idx];
|
|
|
|
if (idx != 0xFF) {
|
|
mEv_event_today_c* today_event = &event_today[idx];
|
|
|
|
if ((today_event->status & mEv_STATUS_EXIST) == FALSE) {
|
|
int flags = 0;
|
|
mEv_place_data_c* place = mEv_get_common_place(today_event->type, 81);
|
|
|
|
if (place != NULL && place->block.x == event->block_x && place->block.z == event->block_z) {
|
|
flags |= 0b00000001; // 1, in the block the event is supposed to exist
|
|
}
|
|
|
|
if (mEv_check_status(today_event->type, mEv_STATUS_RUN)) {
|
|
flags |= 0b00000010; // 2, event is currently running
|
|
today_event->active_hours = 0x20000000;
|
|
}
|
|
|
|
if (type == today_event->type && flags == 0) {
|
|
today_event->type = -1;
|
|
n_today_events--;
|
|
today_event->active_hours = 0;
|
|
today_event->end_date.raw = 0;
|
|
today_event->status = 0;
|
|
index_today[type] = 0xFF;
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static int delete_too_short_event(Event_c* event, int type, mEv_schedule_date_u date) {
|
|
u8 idx = index_today[type];
|
|
|
|
if (idx != 0xFF) {
|
|
mEv_event_today_c* today_event = &event_today[idx];
|
|
mEv_schedule_date_u new_date;
|
|
|
|
switch (today_event->type) {
|
|
case mEv_EVENT_NEW_YEARS_DAY:
|
|
case mEv_EVENT_GROUNDHOG_DAY:
|
|
case mEv_EVENT_SPORTS_FAIR_BALL_TOSS:
|
|
case mEv_EVENT_SPORTS_FAIR_AEROBICS:
|
|
case mEv_EVENT_SPORTS_FAIR_TUG_OF_WAR:
|
|
case mEv_EVENT_SPORTS_FAIR_FOOT_RACE:
|
|
case mEv_EVENT_CHERRY_BLOSSOM_FESTIVAL:
|
|
case mEv_EVENT_FISHING_TOURNEY_1:
|
|
case mEv_EVENT_FIREWORKS_SHOW:
|
|
case mEv_EVENT_MORNING_AEROBICS:
|
|
case mEv_EVENT_HARVEST_MOON_FESTIVAL:
|
|
case mEv_EVENT_FISHING_TOURNEY_2:
|
|
case mEv_EVENT_HARVEST_FESTIVAL:
|
|
{
|
|
new_date = date;
|
|
new_date.hour = mEv_get_end_time(today_event->type);
|
|
|
|
break;
|
|
}
|
|
|
|
case mEv_EVENT_HALLOWEEN:
|
|
case mEv_EVENT_TOY_DAY_JINGLE:
|
|
case mEv_EVENT_NEW_YEARS_EVE_COUNTDOWN:
|
|
{
|
|
new_date.raw = 0;
|
|
new_date.month_day = today_event->end_date;
|
|
new_date.hour = mEv_get_end_time(today_event->type);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (new_date.raw != date.raw) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (Common_Get(time.rtc_time).min < 55) {
|
|
return FALSE;
|
|
}
|
|
|
|
Common_Get(event_common).too_short = type;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void init_today_event() {
|
|
mEv_event_today_c* today_event = event_today;
|
|
int i;
|
|
|
|
for (i = 0; i < mEv_TODAY_EVENT_NUM; i++) {
|
|
today_event->type = -1;
|
|
today_event->active_hours = 0;
|
|
today_event->end_date.raw = 0;
|
|
today_event->begin_date.raw = 0;
|
|
today_event->status = 0;
|
|
|
|
today_event++;
|
|
}
|
|
|
|
n_today_events = 0;
|
|
|
|
{
|
|
u8* index_today_p = index_today;
|
|
|
|
for (i = 0; i < mEv_EVENT_NUM; i++) {
|
|
index_today_p[0] = 0xFF;
|
|
index_today_p++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void init_time_seat() {
|
|
mEv_event_today_c* today_event = event_today;
|
|
int i;
|
|
|
|
for (i = 0; i < mEv_TODAY_EVENT_NUM; i++) {
|
|
today_event->active_hours = 0;
|
|
today_event->end_date.raw = 0;
|
|
today_event->begin_date.raw = 0;
|
|
today_event->status &= ~mEv_STATUS_EXIST;
|
|
}
|
|
}
|
|
|
|
static int get_special_event_end_time(s16 event_type) {
|
|
int end_time = 0;
|
|
|
|
switch (event_type) {
|
|
case mEv_EVENT_DESIGNER:
|
|
end_time = 5;
|
|
break;
|
|
case mEv_EVENT_ARTIST:
|
|
end_time = 5;
|
|
break;
|
|
case mEv_EVENT_CARPET_PEDDLER:
|
|
end_time = 5;
|
|
break;
|
|
case mEv_EVENT_GYPSY:
|
|
end_time = 20;
|
|
break;
|
|
case mEv_EVENT_BROKER_SALE:
|
|
end_time = 17;
|
|
break;
|
|
case mEv_EVENT_SHOP_SALE:
|
|
end_time = 23;
|
|
break;
|
|
}
|
|
|
|
return end_time;
|
|
}
|
|
|
|
static int init_special_init(int new_event) {
|
|
int res = FALSE;
|
|
|
|
switch (Save_Get(scene_no)) {
|
|
case SCENE_BUGGY:
|
|
case SCENE_BROKER_SHOP:
|
|
{
|
|
if (gamePT->frame_counter == 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (Save_Get(scene_no)) {
|
|
case SCENE_BUGGY:
|
|
case SCENE_BROKER_SHOP:
|
|
return FALSE;
|
|
|
|
case SCENE_SHOP0:
|
|
case SCENE_CONVENI:
|
|
case SCENE_SUPER:
|
|
case SCENE_DEPART:
|
|
case SCENE_DEPART_2:
|
|
{
|
|
if (Save_Get(event_save_data).special.type == mEv_EVENT_SHOP_SALE) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// fallthrough case
|
|
default:
|
|
{
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|