Merge branch 'master' into easy_chat

src/battle_1.c

@@ -0,0 +1,17 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u32 gUnknown_03000DD4;
+IWRAM_DATA u32 gUnknown_03000DD8;
+IWRAM_DATA u32 gUnknown_03000DDC;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/battle_4.c

@@ -1,601 +0,0 @@
-#include "global.h"
-#include "battle.h"
-#include "battle_move_effects.h"
-#include "moves.h"
-#include "abilities.h"
-#include "item.h"
-#include "items.h"
-#include "hold_effects.h"
-
-void atk00_attackcanceler(void);
-void atk01_accuracycheck(void);
-void atk02_attackstring(void);
-void atk03_ppreduce(void);
-void atk04_critcalc(void);
-void atk05_damagecalc1(void);
-void atk06_typecalc(void);
-void atk07_dmg_adjustment(void);
-void atk08_dmg_adjustment2(void);
-void atk09_attackanimation(void);
-void atk0A_waitanimation(void);
-void atk0B_healthbarupdate(void);
-void atk0C_datahpupdate(void);
-void atk0D_critmessage(void);
-void atk0E_effectiveness_sound(void);
-void atk0F_resultmessage(void);
-void atk10_printstring(void);
-void atk11_printstring_playeronly(void);
-void atk12_waitmessage(void);
-void atk13_printfromtable(void);
-void atk14_printfromtable_playeronly(void);
-void atk15_seteffectwithchancetarget(void);
-void atk16_seteffectprimary(void);
-void atk17_seteffectsecondary(void);
-void atk18_status_effect_clear(void);
-void atk19_faint_pokemon(void);
-void atk1A_faint_animation(void);
-void atk1B_faint_effects_clear(void);
-void atk1C_jumpifstatus(void);
-void atk1D_jumpifstatus2(void);
-void atk1E_jumpifability(void);
-void atk1F_jumpifsideaffecting(void);
-void atk20_jumpifstat(void);
-void atk21_jumpifstatus3(void);
-void atk22_jumpiftype(void);
-void atk23_getexp(void);
-void atk24(void);
-void atk25_move_values_cleanup(void);
-void atk26_set_multihit(void);
-void atk27_decrement_multihit(void);
-void atk28_goto(void);
-void atk29_jumpifbyte(void);
-void atk2A_jumpifhalfword(void);
-void atk2B_jumpifword(void);
-void atk2C_jumpifarrayequal(void);
-void atk2D_jumpifarraynotequal(void);
-void atk2E_setbyte(void);
-void atk2F_addbyte(void);
-void atk30_subbyte(void);
-void atk31_copyarray(void);
-void atk32_copyarray_withindex(void);
-void atk33_orbyte(void);
-void atk34_orhalfword(void);
-void atk35_orword(void);
-void atk36_bicbyte(void);
-void atk37_bichalfword(void);
-void atk38_bicword(void);
-void atk39_pause(void);
-void atk3A_waitstate(void);
-void atk3B_healthbar_update(void);
-void atk3C_return(void);
-void atk3D_end(void);
-void atk3E_end2(void);
-void atk3F_end3(void);
-void atk40_jump_if_move_affected_by_protect(void);
-void atk41_call(void);
-void atk42_jumpiftype2(void);
-void atk43_jumpifabilitypresent(void);
-void atk44(void);
-void atk45_playanimation(void);
-void atk46_playanimation2(void);
-void atk47_setgraphicalstatchangevalues(void);
-void atk48_playstatchangeanimation(void);
-void atk49_moveendturn(void);
-void atk4A_typecalc2(void);
-void atk4B_return_atk_to_ball(void);
-void atk4C_copy_poke_data(void);
-void atk4D_switch_data_update(void);
-void atk4E_switchin_anim(void);
-void atk4F_jump_if_cannot_switch(void);
-void atk50_openpartyscreen(void);
-void atk51_switch_handle_order(void);
-void atk52_switch_in_effects(void);
-void atk53_trainer_slide(void);
-void atk54_effectiveness_sound(void);
-void atk55_play_sound(void);
-void atk56_fainting_cry(void);
-void atk57(void);
-void atk58_return_to_ball(void);
-void atk59_learnmove_inbattle(void);
-void atk5A(void);
-void atk5B_80256E0(void);
-void atk5C_hitanimation(void);
-void atk5D_getmoneyreward(void);
-void atk5E_8025A70(void);
-void atk5F_8025B24(void);
-void atk60_increment_gamestat(void);
-void atk61_8025BA4(void);
-void atk62_08025C6C(void);
-void atk63_jumptorandomattack(void);
-void atk64_statusanimation(void);
-void atk65_status2animation(void);
-void atk66_chosenstatusanimation(void);
-void atk67_8025ECC(void);
-void atk68_80246A0(void);
-void atk69_dmg_adjustment2(void);
-void atk6A_removeitem(void);
-void atk6B_atknameinbuff1(void);
-void atk6C_lvlbox_display(void);
-void atk6D_set_sentpokes_values(void);
-void atk6E_set_atk_to_player0(void);
-void atk6F_set_visible(void);
-void atk70_record_ability(void);
-void atk71_buffer_move_to_learn(void);
-void atk72_jump_if_can_run_frombattle(void);
-void atk73_hp_thresholds(void);
-void atk74_hp_thresholds2(void);
-void atk75_8026A58(void);
-void atk76_various(void);
-void atk77_setprotect(void);
-void atk78_faintifabilitynotdamp(void);
-void atk79_setatkhptozero(void);
-void atk7A_jumpwhiletargetvalid(void);
-void atk7B_healhalfHP_if_possible(void);
-void atk7C_8025508(void);
-void atk7D_set_rain(void);
-void atk7E_setreflect(void);
-void atk7F_setseeded(void);
-void atk80_manipulatedamage(void);
-void atk81_setrest(void);
-void atk82_jumpifnotfirstturn(void);
-void atk83_nop(void);
-void atk84_jump_if_cant_sleep(void);
-void atk85_stockpile(void);
-void atk86_stockpiletobasedamage(void);
-void atk87_stockpiletohpheal(void);
-void atk88_negativedamage(void);
-void atk89_statbuffchange(void);
-void atk8A_normalisebuffs(void);
-void atk8B_setbide(void);
-void atk8C_confuseifrepeatingattackends(void);
-void atk8D_setmultihit_counter(void);
-void atk8E_prepare_multihit(void);
-void atk8F_forcerandomswitch(void);
-void atk90_conversion_type_change(void);
-void atk91_givepaydaymoney(void);
-void atk92_setlightscreen(void);
-void atk93_ko_move(void);
-void atk94_gethalfcurrentenemyhp(void);
-void atk95_setsandstorm(void);
-void atk96_weatherdamage(void);
-void atk97_try_infatuation(void);
-void atk98_status_icon_update(void);
-void atk99_setmist(void);
-void atk9A_set_focusenergy(void);
-void atk9B_transformdataexecution(void);
-void atk9C_set_substitute(void);
-void atk9D_copyattack(void);
-void atk9E_metronome(void);
-void atk9F_dmgtolevel(void);
-void atkA0_psywavedamageeffect(void);
-void atkA1_counterdamagecalculator(void);
-void atkA2_mirrorcoatdamagecalculator(void);
-void atkA3_disablelastusedattack(void);
-void atkA4_setencore(void);
-void atkA5_painsplitdmgcalc(void);
-void atkA6_settypetorandomresistance(void);
-void atkA7_setalwayshitflag(void);
-void atkA8_copymovepermanently(void);
-void atkA9_sleeptalk_choose_move(void);
-void atkAA_set_destinybond(void);
-void atkAB_DestinyBondFlagUpdate(void);
-void atkAC_remaininghptopower(void);
-void atkAD_spite_ppreduce(void);
-void atkAE_heal_party_status(void);
-void atkAF_cursetarget(void);
-void atkB0_set_spikes(void);
-void atkB1_set_foresight(void);
-void atkB2_setperishsong(void);
-void atkB3_rolloutdamagecalculation(void);
-void atkB4_jumpifconfusedandstatmaxed(void);
-void atkB5_furycuttercalc(void);
-void atkB6_happinesstodamagecalculation(void);
-void atkB7_presentdamagecalculation(void);
-void atkB8_set_safeguard(void);
-void atkB9_magnitudedamagecalculation(void);
-void atkBA_jumpifnopursuitswitchdmg(void);
-void atkBB_setsunny(void);
-void atkBC_maxattackhalvehp(void);
-void atkBD_copyfoestats(void);
-void atkBE_breakfree(void);
-void atkBF_set_defense_curl(void);
-void atkC0_recoverbasedonsunlight(void);
-void atkC1_hidden_power(void);
-void atkC2_selectnexttarget(void);
-void atkC3_setfutureattack(void);
-void atkC4_beat_up(void);
-void atkC5_hidepreattack(void);
-void atkC6_unhidepostattack(void);
-void atkC7_setminimize(void);
-void atkC8_sethail(void);
-void atkC9_jumpifattackandspecialattackcannotfall(void);
-void atkCA_setforcedtarget(void);
-void atkCB_setcharge(void);
-void atkCC_callterrainattack(void);
-void atkCD_cureifburnedparalysedorpoisoned(void);
-void atkCE_settorment(void);
-void atkCF_jumpifnodamage(void);
-void atkD0_settaunt(void);
-void atkD1_set_helpinghand(void);
-void atkD2_swap_items(void);
-void atkD3_copy_ability(void);
-void atkD4_wish_effect(void);
-void atkD5_setroots(void);
-void atkD6_doubledamagedealtifdamaged(void);
-void atkD7_setyawn(void);
-void atkD8_setdamagetohealthdifference(void);
-void atkD9_scaledamagebyhealthratio(void);
-void atkDA_abilityswap(void);
-void atkDB_imprisoneffect(void);
-void atkDC_setgrudge(void);
-void atkDD_weightdamagecalculation(void);
-void atkDE_asistattackselect(void);
-void atkDF_setmagiccoat(void);
-void atkE0_setstealstatchange(void);
-void atkE1_intimidate_string_loader(void);
-void atkE2_switchout_abilities(void);
-void atkE3_jumpiffainted(void);
-void atkE4_getsecretpowereffect(void);
-void atkE5_pickup(void);
-void atkE6_castform_change_animation(void);
-void atkE7_castform_data_change(void);
-void atkE8_settypebasedhalvers(void);
-void atkE9_setweatherballtype(void);
-void atkEA_recycleitem(void);
-void atkEB_settypetoterrain(void);
-void atkEC_pursuit_sth(void);
-void atkED_802B4B4(void);
-void atkEE_removelightscreenreflect(void);
-void atkEF_pokeball_catch_calculation(void);
-void atkF0_copy_caught_poke(void);
-void atkF1_setpoke_as_caught(void);
-void atkF2_display_dex_info(void);
-void atkF3_nickname_caught_poke(void);
-void atkF4_802BEF0(void);
-void atkF5_removeattackerstatus1(void);
-void atkF6_802BF48(void);
-void atkF7_802BF54(void);
-void sub_8056EF8(void);
-
-void (* const gBattleScriptingCommandsTable[])(void) =
-{
-    atk00_attackcanceler,
-    atk01_accuracycheck,
-    atk02_attackstring,
-    atk03_ppreduce,
-    atk04_critcalc,
-    atk05_damagecalc1,
-    atk06_typecalc,
-    atk07_dmg_adjustment,
-    atk08_dmg_adjustment2,
-    atk09_attackanimation,
-    atk0A_waitanimation,
-    atk0B_healthbarupdate,
-    atk0C_datahpupdate,
-    atk0D_critmessage,
-    atk0E_effectiveness_sound,
-    atk0F_resultmessage,
-    atk10_printstring,
-    atk11_printstring_playeronly,
-    atk12_waitmessage,
-    atk13_printfromtable,
-    atk14_printfromtable_playeronly,
-    atk15_seteffectwithchancetarget,
-    atk16_seteffectprimary,
-    atk17_seteffectsecondary,
-    atk18_status_effect_clear,
-    atk19_faint_pokemon,
-    atk1A_faint_animation,
-    atk1B_faint_effects_clear,
-    atk1C_jumpifstatus,
-    atk1D_jumpifstatus2,
-    atk1E_jumpifability,
-    atk1F_jumpifsideaffecting,
-    atk20_jumpifstat,
-    atk21_jumpifstatus3,
-    atk22_jumpiftype,
-    atk23_getexp,
-    atk24,
-    atk25_move_values_cleanup,
-    atk26_set_multihit,
-    atk27_decrement_multihit,
-    atk28_goto,
-    atk29_jumpifbyte,
-    atk2A_jumpifhalfword,
-    atk2B_jumpifword,
-    atk2C_jumpifarrayequal,
-    atk2D_jumpifarraynotequal,
-    atk2E_setbyte,
-    atk2F_addbyte,
-    atk30_subbyte,
-    atk31_copyarray,
-    atk32_copyarray_withindex,
-    atk33_orbyte,
-    atk34_orhalfword,
-    atk35_orword,
-    atk36_bicbyte,
-    atk37_bichalfword,
-    atk38_bicword,
-    atk39_pause,
-    atk3A_waitstate,
-    atk3B_healthbar_update,
-    atk3C_return,
-    atk3D_end,
-    atk3E_end2,
-    atk3F_end3,
-    atk40_jump_if_move_affected_by_protect,
-    atk41_call,
-    atk42_jumpiftype2,
-    atk43_jumpifabilitypresent,
-    atk44,
-    atk45_playanimation,
-    atk46_playanimation2,
-    atk47_setgraphicalstatchangevalues,
-    atk48_playstatchangeanimation,
-    atk49_moveendturn,
-    atk4A_typecalc2,
-    atk4B_return_atk_to_ball,
-    atk4C_copy_poke_data,
-    atk4D_switch_data_update,
-    atk4E_switchin_anim,
-    atk4F_jump_if_cannot_switch,
-    atk50_openpartyscreen,
-    atk51_switch_handle_order,
-    atk52_switch_in_effects,
-    atk53_trainer_slide,
-    atk54_effectiveness_sound,
-    atk55_play_sound,
-    atk56_fainting_cry,
-    atk57,
-    atk58_return_to_ball,
-    atk59_learnmove_inbattle,
-    atk5A,
-    atk5B_80256E0,
-    atk5C_hitanimation,
-    atk5D_getmoneyreward,
-    atk5E_8025A70,
-    atk5F_8025B24,
-    atk60_increment_gamestat,
-    atk61_8025BA4,
-    atk62_08025C6C,
-    atk63_jumptorandomattack,
-    atk64_statusanimation,
-    atk65_status2animation,
-    atk66_chosenstatusanimation,
-    atk67_8025ECC,
-    atk68_80246A0,
-    atk69_dmg_adjustment2,
-    atk6A_removeitem,
-    atk6B_atknameinbuff1,
-    atk6C_lvlbox_display,
-    atk6D_set_sentpokes_values,
-    atk6E_set_atk_to_player0,
-    atk6F_set_visible,
-    atk70_record_ability,
-    atk71_buffer_move_to_learn,
-    atk72_jump_if_can_run_frombattle,
-    atk73_hp_thresholds,
-    atk74_hp_thresholds2,
-    atk75_8026A58,
-    atk76_various,
-    atk77_setprotect,
-    atk78_faintifabilitynotdamp,
-    atk79_setatkhptozero,
-    atk7A_jumpwhiletargetvalid,
-    atk7B_healhalfHP_if_possible,
-    atk7C_8025508,
-    atk7D_set_rain,
-    atk7E_setreflect,
-    atk7F_setseeded,
-    atk80_manipulatedamage,
-    atk81_setrest,
-    atk82_jumpifnotfirstturn,
-    atk83_nop,
-    atk84_jump_if_cant_sleep,
-    atk85_stockpile,
-    atk86_stockpiletobasedamage,
-    atk87_stockpiletohpheal,
-    atk88_negativedamage,
-    atk89_statbuffchange,
-    atk8A_normalisebuffs,
-    atk8B_setbide,
-    atk8C_confuseifrepeatingattackends,
-    atk8D_setmultihit_counter,
-    atk8E_prepare_multihit,
-    atk8F_forcerandomswitch,
-    atk90_conversion_type_change,
-    atk91_givepaydaymoney,
-    atk92_setlightscreen,
-    atk93_ko_move,
-    atk94_gethalfcurrentenemyhp,
-    atk95_setsandstorm,
-    atk96_weatherdamage,
-    atk97_try_infatuation,
-    atk98_status_icon_update,
-    atk99_setmist,
-    atk9A_set_focusenergy,
-    atk9B_transformdataexecution,
-    atk9C_set_substitute,
-    atk9D_copyattack,
-    atk9E_metronome,
-    atk9F_dmgtolevel,
-    atkA0_psywavedamageeffect,
-    atkA1_counterdamagecalculator,
-    atkA2_mirrorcoatdamagecalculator,
-    atkA3_disablelastusedattack,
-    atkA4_setencore,
-    atkA5_painsplitdmgcalc,
-    atkA6_settypetorandomresistance,
-    atkA7_setalwayshitflag,
-    atkA8_copymovepermanently,
-    atkA9_sleeptalk_choose_move,
-    atkAA_set_destinybond,
-    atkAB_DestinyBondFlagUpdate,
-    atkAC_remaininghptopower,
-    atkAD_spite_ppreduce,
-    atkAE_heal_party_status,
-    atkAF_cursetarget,
-    atkB0_set_spikes,
-    atkB1_set_foresight,
-    atkB2_setperishsong,
-    atkB3_rolloutdamagecalculation,
-    atkB4_jumpifconfusedandstatmaxed,
-    atkB5_furycuttercalc,
-    atkB6_happinesstodamagecalculation,
-    atkB7_presentdamagecalculation,
-    atkB8_set_safeguard,
-    atkB9_magnitudedamagecalculation,
-    atkBA_jumpifnopursuitswitchdmg,
-    atkBB_setsunny,
-    atkBC_maxattackhalvehp,
-    atkBD_copyfoestats,
-    atkBE_breakfree,
-    atkBF_set_defense_curl,
-    atkC0_recoverbasedonsunlight,
-    atkC1_hidden_power,
-    atkC2_selectnexttarget,
-    atkC3_setfutureattack,
-    atkC4_beat_up,
-    atkC5_hidepreattack,
-    atkC6_unhidepostattack,
-    atkC7_setminimize,
-    atkC8_sethail,
-    atkC9_jumpifattackandspecialattackcannotfall,
-    atkCA_setforcedtarget,
-    atkCB_setcharge,
-    atkCC_callterrainattack,
-    atkCD_cureifburnedparalysedorpoisoned,
-    atkCE_settorment,
-    atkCF_jumpifnodamage,
-    atkD0_settaunt,
-    atkD1_set_helpinghand,
-    atkD2_swap_items,
-    atkD3_copy_ability,
-    atkD4_wish_effect,
-    atkD5_setroots,
-    atkD6_doubledamagedealtifdamaged,
-    atkD7_setyawn,
-    atkD8_setdamagetohealthdifference,
-    atkD9_scaledamagebyhealthratio,
-    atkDA_abilityswap,
-    atkDB_imprisoneffect,
-    atkDC_setgrudge,
-    atkDD_weightdamagecalculation,
-    atkDE_asistattackselect,
-    atkDF_setmagiccoat,
-    atkE0_setstealstatchange,
-    atkE1_intimidate_string_loader,
-    atkE2_switchout_abilities,
-    atkE3_jumpiffainted,
-    atkE4_getsecretpowereffect,
-    atkE5_pickup,
-    atkE6_castform_change_animation,
-    atkE7_castform_data_change,
-    atkE8_settypebasedhalvers,
-    atkE9_setweatherballtype,
-    atkEA_recycleitem,
-    atkEB_settypetoterrain,
-    atkEC_pursuit_sth,
-    atkED_802B4B4,
-    atkEE_removelightscreenreflect,
-    atkEF_pokeball_catch_calculation,
-    atkF0_copy_caught_poke,
-    atkF1_setpoke_as_caught,
-    atkF2_display_dex_info,
-    atkF3_nickname_caught_poke,
-    atkF4_802BEF0,
-    atkF5_removeattackerstatus1,
-    atkF6_802BF48,
-    atkF7_802BF54,
-    sub_8056EF8
-};
-
-struct statFractions
-{
-    u8 dividend;
-    u8 divisor;
-};
-
-const struct statFractions gAccuracyStageRatios[] =
-{
-    { 33, 100}, // -6
-    { 36, 100}, // -5
-    { 43, 100}, // -4
-    { 50, 100}, // -3
-    { 60, 100}, // -2
-    { 75, 100}, // -1
-    {  1,   1}, //  0
-    {133, 100}, // +1
-    {166, 100}, // +2
-    {  2,   1}, // +3
-    {233, 100}, // +4
-    {133,  50}, // +5
-    {  3,   1}, // +6
-};
-
-// The chance is 1/N for each stage.
-const u16 gCriticalHitChance[] = {16, 8, 4, 3, 2};
-
-const u32 gStatusFlagsForMoveEffects[] =
-{
-    0x00000000,
-    0x00000007,
-    0x00000008,
-    0x00000010,
-    0x00000020,
-    0x00000040,
-    0x00000080,
-    0x00000007,
-    0x00000008,
-    0x00000000,
-    0x00000070,
-    0x00000000,
-    0x00001000,
-    0x0000E000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00400000,
-    0x00000000,
-    0x00000000,
-    0x04000000,
-    0x08000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000C00,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000,
-    0x00000000
-};

src/battle_ai_switch_items.c

@@ -0,0 +1,951 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "abilities.h"
+#include "moves.h"
+#include "pokemon.h"
+#include "species.h"
+#include "rng.h"
+#include "util.h"
+#include "items.h"
+#include "pokemon_item_effects.h"
+
+extern u8 gActiveBank;
+extern u8 gAbsentBankFlags;
+extern u32 gBattleTypeFlags;
+extern u32 gStatuses3[BATTLE_BANKS_COUNT];
+extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u16 gUnknown_02024250[BATTLE_BANKS_COUNT];
+extern u8 gUnknown_02024270[BATTLE_BANKS_COUNT];
+extern u16 gDynamicBasePower;
+extern u8 gBattleMoveFlags;
+extern u8 gCritMultiplier;
+extern s32 gBattleMoveDamage;
+
+extern const struct BattleMove gBattleMoves[];
+extern const struct BaseStats gBaseStats[];
+extern const u8 gTypeEffectiveness[];
+extern const u8 * const gItemEffectTable[]; // todo: fix once struct is declared
+
+// this file's functions
+static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng);
+static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent);
+static bool8 ShouldUseItem(void);
+
+static bool8 ShouldSwitchIfPerishSong(void)
+{
+    if (gStatuses3[gActiveBank] & STATUS3_PERISH_SONG
+        && gDisableStructs[gActiveBank].perishSong1 == 0)
+    {
+        *(gBattleStruct->field_294 + gActiveBank) = 6;
+        EmitCmd33(1, 2, 0);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static bool8 ShouldSwitchIfWonderGuard(void)
+{
+    u8 opposingIdentity;
+    u8 opposingBank;
+    u8 moveFlags;
+    s32 i, j;
+    s32 firstId;
+    s32 lastId; // + 1
+    struct Pokemon *party = NULL;
+    u16 move;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+        return FALSE;
+
+    opposingIdentity = GetBankIdentity(gActiveBank) ^ BIT_SIDE;
+
+    if (gBattleMons[GetBankByIdentity(opposingIdentity)].ability != ABILITY_WONDER_GUARD)
+        return FALSE;
+
+    // check if pokemon has a super effective move
+    for (opposingBank = GetBankByIdentity(opposingIdentity), i = 0; i < 4; i++)
+    {
+        move = gBattleMons[gActiveBank].moves[i];
+        if (move == MOVE_NONE)
+            continue;
+
+        moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
+        if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            return FALSE;
+    }
+
+    // get party information
+    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+    {
+        if ((gActiveBank & BIT_MON) == 0)
+            firstId = 0, lastId = 3;
+        else
+            firstId = 3, lastId = 6;
+    }
+    else
+    {
+        firstId = 0, lastId = 6;
+    }
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    // find a pokemon in the party that has a super effective move
+    for (i = firstId; i < lastId; i++)
+    {
+        if (GetMonData(&party[i], MON_DATA_HP) == 0)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_NONE)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+            continue;
+        if (i == gBattlePartyID[gActiveBank])
+            continue;
+
+        GetMonData(&party[i], MON_DATA_SPECIES); // unused return value
+        GetMonData(&party[i], MON_DATA_ALT_ABILITY); // unused return value
+
+        for (opposingBank = GetBankByIdentity(opposingIdentity), j = 0; j < 4; j++)
+        {
+            move = GetMonData(&party[i], MON_DATA_MOVE1 + j);
+            if (move == MOVE_NONE)
+                continue;
+
+            moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
+            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % 3 < 2)
+            {
+                // we found a mon
+                *(gBattleStruct->field_294 + gActiveBank) = i;
+                EmitCmd33(1, 2, 0);
+                return TRUE;
+            }
+        }
+    }
+
+    return FALSE; // at this point there is not a single pokemon in the party that has a super effective move against a pokemon with wonder guard
+}
+
+static bool8 FindMonThatAbsorbsOpponentsMove(void)
+{
+    u8 bankIn1, bankIn2;
+    u8 absorbingTypeAbility;
+    s32 firstId;
+    s32 lastId; // + 1
+    struct Pokemon *party;
+    s32 i;
+
+    if (HasSuperEffectiveMoveAgainstOpponents(TRUE) && Random() % 3 != 0)
+        return FALSE;
+    if (gUnknown_02024250[gActiveBank] == 0)
+        return FALSE;
+    if (gUnknown_02024250[gActiveBank] == 0xFFFF)
+        return FALSE;
+    if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0)
+        return FALSE;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+    {
+        bankIn1 = gActiveBank;
+        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
+            bankIn2 = gActiveBank;
+        else
+            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+    }
+    else
+    {
+        bankIn1 = gActiveBank;
+        bankIn2 = gActiveBank;
+    }
+
+    if (gBattleMoves[gUnknown_02024250[gActiveBank]].type == TYPE_FIRE)
+        absorbingTypeAbility = ABILITY_FLASH_FIRE;
+    else if (gBattleMoves[gUnknown_02024250[gActiveBank]].type == TYPE_WATER)
+        absorbingTypeAbility = ABILITY_WATER_ABSORB;
+    else if (gBattleMoves[gUnknown_02024250[gActiveBank]].type == TYPE_ELECTRIC)
+        absorbingTypeAbility = ABILITY_VOLT_ABSORB;
+    else
+        return FALSE;
+
+    if (gBattleMons[gActiveBank].ability == absorbingTypeAbility)
+        return FALSE;
+
+    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+    {
+        if ((gActiveBank & BIT_MON) == 0)
+            firstId = 0, lastId = 3;
+        else
+            firstId = 3, lastId = 6;
+    }
+    else
+    {
+        firstId = 0, lastId = 6;
+    }
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    for (i = firstId; i < lastId; i++)
+    {
+        u16 species;
+        u8 monAbility;
+
+        if (GetMonData(&party[i], MON_DATA_HP) == 0)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_NONE)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+            continue;
+        if (i == gBattlePartyID[bankIn1])
+            continue;
+        if (i == gBattlePartyID[bankIn2])
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn1))
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn2))
+            continue;
+
+        species = GetMonData(&party[i], MON_DATA_SPECIES);
+        if (GetMonData(&party[i], MON_DATA_ALT_ABILITY) != 0)
+            monAbility = gBaseStats[species].ability2;
+        else
+            monAbility = gBaseStats[species].ability1;
+
+        if (absorbingTypeAbility == monAbility && Random() & 1)
+        {
+            // we found a mon
+            *(gBattleStruct->field_294 + gActiveBank) = i;
+            EmitCmd33(1, 2, 0);
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static bool8 ShouldSwitchIfNaturalCure(void)
+{
+    if (!(gBattleMons[gActiveBank].status1 & STATUS_SLEEP))
+        return FALSE;
+    if (gBattleMons[gActiveBank].ability != ABILITY_NATURAL_CURE)
+        return FALSE;
+    if (gBattleMons[gActiveBank].hp < gBattleMons[gActiveBank].maxHP / 2)
+        return FALSE;
+
+    if ((gUnknown_02024250[gActiveBank] == 0 || gUnknown_02024250[gActiveBank] == 0xFFFF) && Random() & 1)
+    {
+        *(gBattleStruct->field_294 + gActiveBank) = 6;
+        EmitCmd33(1, 2, 0);
+        return TRUE;
+    }
+    else if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0 && Random() & 1)
+    {
+        *(gBattleStruct->field_294 + gActiveBank) = 6;
+        EmitCmd33(1, 2, 0);
+        return TRUE;
+    }
+
+    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTAFFECTED, 1))
+        return TRUE;
+    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTVERYEFFECTIVE, 1))
+        return TRUE;
+    if (Random() & 1)
+    {
+        *(gBattleStruct->field_294 + gActiveBank) = 6;
+        EmitCmd33(1, 2, 0);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng)
+{
+    u8 opposingIdentity;
+    u8 opposingBank;
+    s32 i;
+    u8 moveFlags;
+    u16 move;
+
+    opposingIdentity = GetBankIdentity(gActiveBank) ^ BIT_SIDE;
+    opposingBank = GetBankByIdentity(opposingIdentity);
+
+    if (!(gAbsentBankFlags & gBitTable[opposingBank]))
+    {
+        for (i = 0; i < 4; i++)
+        {
+            move = gBattleMons[gActiveBank].moves[i];
+            if (move == MOVE_NONE)
+                continue;
+
+            moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
+            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            {
+                if (noRng)
+                    return TRUE;
+                if (Random() % 10 != 0)
+                    return TRUE;
+            }
+        }
+    }
+    if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+        return FALSE;
+
+    opposingBank = GetBankByIdentity(opposingIdentity ^ BIT_MON);
+
+    if (!(gAbsentBankFlags & gBitTable[opposingBank]))
+    {
+        for (i = 0; i < 4; i++)
+        {
+            move = gBattleMons[gActiveBank].moves[i];
+            if (move == MOVE_NONE)
+                continue;
+
+            moveFlags = AI_TypeCalc(move, gBattleMons[opposingBank].species, gBattleMons[opposingBank].ability);
+            if (moveFlags & MOVESTATUS_SUPEREFFECTIVE)
+            {
+                if (noRng)
+                    return TRUE;
+                if (Random() % 10 != 0)
+                    return TRUE;
+            }
+        }
+    }
+
+    return FALSE;
+}
+
+static bool8 AreStatsRaised(void)
+{
+    u8 buffedStatsValue = 0;
+    s32 i;
+
+    for (i = 0; i < BATTLE_STATS_NO; i++)
+    {
+        if (gBattleMons[gActiveBank].statStages[i] > 6)
+            buffedStatsValue += gBattleMons[gActiveBank].statStages[i] - 6;
+    }
+
+    return (buffedStatsValue > 3);
+}
+
+static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
+{
+    u8 bankIn1, bankIn2;
+    s32 firstId;
+    s32 lastId; // + 1
+    struct Pokemon *party;
+    s32 i, j;
+    u16 move;
+    u8 moveFlags;
+
+    if (gUnknown_02024250[gActiveBank] == 0)
+        return FALSE;
+    if (gUnknown_02024250[gActiveBank] == 0xFFFF)
+        return FALSE;
+    if (gUnknown_02024270[gActiveBank] == 0xFF)
+        return FALSE;
+    if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0)
+        return FALSE;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+    {
+        bankIn1 = gActiveBank;
+        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
+            bankIn2 = gActiveBank;
+        else
+            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+    }
+    else
+    {
+        bankIn1 = gActiveBank;
+        bankIn2 = gActiveBank;
+    }
+
+    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+    {
+        if ((gActiveBank & BIT_MON) == 0)
+            firstId = 0, lastId = 3;
+        else
+            firstId = 3, lastId = 6;
+    }
+    else
+    {
+        firstId = 0, lastId = 6;
+    }
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    for (i = firstId; i < lastId; i++)
+    {
+        u16 species;
+        u8 monAbility;
+
+        if (GetMonData(&party[i], MON_DATA_HP) == 0)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_NONE)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+            continue;
+        if (i == gBattlePartyID[bankIn1])
+            continue;
+        if (i == gBattlePartyID[bankIn2])
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn1))
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn2))
+            continue;
+
+        species = GetMonData(&party[i], MON_DATA_SPECIES);
+        if (GetMonData(&party[i], MON_DATA_ALT_ABILITY) != 0)
+            monAbility = gBaseStats[species].ability2;
+        else
+            monAbility = gBaseStats[species].ability1;
+
+        moveFlags = AI_TypeCalc(gUnknown_02024250[gActiveBank], species, monAbility);
+        if (moveFlags & flags)
+        {
+            bankIn1 = gUnknown_02024270[gActiveBank];
+
+            for (j = 0; j < 4; j++)
+            {
+                move = GetMonData(&party[i], MON_DATA_MOVE1 + j);
+                if (move == 0)
+                    continue;
+
+                moveFlags = AI_TypeCalc(move, gBattleMons[bankIn1].species, gBattleMons[bankIn1].ability);
+                if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % moduloPercent == 0)
+                {
+                    *(gBattleStruct->field_294 + gActiveBank) = i;
+                    EmitCmd33(1, 2, 0);
+                    return TRUE;
+                }
+            }
+        }
+    }
+
+    return FALSE;
+}
+
+static bool8 ShouldSwitch(void)
+{
+    u8 bankIn1, bankIn2;
+    u8 *activeBankPtr; // needed to match
+    s32 firstId;
+    s32 lastId; // + 1
+    struct Pokemon *party;
+    s32 i;
+    s32 availableToSwitch;
+
+    if (gBattleMons[*(activeBankPtr = &gActiveBank)].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION))
+        return FALSE;
+    if (gStatuses3[gActiveBank] & STATUS3_ROOTED)
+        return FALSE;
+    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBank, ABILITY_SHADOW_TAG, 0, 0))
+        return FALSE;
+    if (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gActiveBank, ABILITY_ARENA_TRAP, 0, 0))
+        return FALSE; // misses the flying or levitate check
+    if (AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_MAGNET_PULL, 0, 0))
+    {
+        if (gBattleMons[gActiveBank].type1 == TYPE_STEEL)
+            return FALSE;
+        if (gBattleMons[gActiveBank].type2 == TYPE_STEEL)
+            return FALSE;
+    }
+    if (gBattleTypeFlags & BATTLE_TYPE_ARENA)
+        return FALSE;
+
+    availableToSwitch = 0;
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+    {
+        bankIn1 = *activeBankPtr;
+        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(*activeBankPtr) ^ BIT_MON)])
+            bankIn2 = *activeBankPtr;
+        else
+            bankIn2 = GetBankByIdentity(GetBankIdentity(*activeBankPtr) ^ BIT_MON);
+    }
+    else
+    {
+        bankIn1 = *activeBankPtr;
+        bankIn2 = *activeBankPtr;
+    }
+
+    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+    {
+        if ((gActiveBank & BIT_MON) == 0)
+            firstId = 0, lastId = 3;
+        else
+            firstId = 3, lastId = 6;
+    }
+    else
+    {
+        firstId = 0, lastId = 6;
+    }
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    for (i = firstId; i < lastId; i++)
+    {
+        if (GetMonData(&party[i], MON_DATA_HP) == 0)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_NONE)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+            continue;
+        if (i == gBattlePartyID[bankIn1])
+            continue;
+        if (i == gBattlePartyID[bankIn2])
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn1))
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn2))
+            continue;
+
+        availableToSwitch++;
+    }
+
+    if (availableToSwitch == 0)
+        return FALSE;
+    if (ShouldSwitchIfPerishSong())
+        return TRUE;
+    if (ShouldSwitchIfWonderGuard())
+        return TRUE;
+    if (FindMonThatAbsorbsOpponentsMove())
+        return TRUE;
+    if (ShouldSwitchIfNaturalCure())
+        return TRUE;
+    if (HasSuperEffectiveMoveAgainstOpponents(FALSE))
+        return FALSE;
+    if (AreStatsRaised())
+        return FALSE;
+    if (FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTAFFECTED, 2)
+        || FindMonWithFlagsAndSuperEffective(MOVESTATUS_NOTVERYEFFECTIVE, 3))
+        return TRUE;
+
+    return FALSE;
+}
+
+void AI_TrySwitchOrUseItem(void)
+{
+    struct Pokemon *party;
+    u8 bankIn1, bankIn2;
+    s32 firstId;
+    s32 lastId; // + 1
+    u8 bankIdentity = GetBankIdentity(gActiveBank);
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+    {
+        if (ShouldSwitch())
+        {
+            if (*(gBattleStruct->field_294 + gActiveBank) == 6)
+            {
+                s32 monToSwitchId = GetMostSuitableMonToSwitchInto();
+                if (monToSwitchId == 6)
+                {
+                    if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+                    {
+                        bankIn1 = GetBankByIdentity(bankIdentity);
+                        bankIn2 = bankIn1;
+                    }
+                    else
+                    {
+                        bankIn1 = GetBankByIdentity(bankIdentity);
+                        bankIn2 = GetBankByIdentity(bankIdentity ^ BIT_MON);
+                    }
+
+                    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+                    {
+                        if ((gActiveBank & BIT_MON) == 0)
+                            firstId = 0, lastId = 3;
+                        else
+                            firstId = 3, lastId = 6;
+                    }
+                    else
+                    {
+                        firstId = 0, lastId = 6;
+                    }
+
+                    for (monToSwitchId = firstId; monToSwitchId < lastId; monToSwitchId++)
+                    {
+                        if (GetMonData(&party[monToSwitchId], MON_DATA_HP) == 0)
+                            continue;
+                        if (monToSwitchId == gBattlePartyID[bankIn1])
+                            continue;
+                        if (monToSwitchId == gBattlePartyID[bankIn2])
+                            continue;
+                        if (monToSwitchId == *(gBattleStruct->field_5C + bankIn1))
+                            continue;
+                        if (monToSwitchId == *(gBattleStruct->field_5C + bankIn2))
+                            continue;
+
+                        break;
+                    }
+                }
+
+                *(gBattleStruct->field_294 + gActiveBank) = monToSwitchId;
+            }
+
+            *(gBattleStruct->field_5C + gActiveBank) = *(gBattleStruct->field_294 + gActiveBank);
+            return;
+        }
+        else if (ShouldUseItem())
+        {
+            return;
+        }
+    }
+
+    EmitCmd33(1, 0, (gActiveBank ^ BIT_SIDE) << 8);
+}
+
+#define TYPE_FORESIGHT  0xFE
+#define TYPE_ENDTABLE   0xFF
+
+static void ModulateByTypeEffectiveness(u8 atkType, u8 defType1, u8 defType2, u8 *var)
+{
+    s32 i = 0;
+
+    while (gTypeEffectiveness[i] != TYPE_ENDTABLE)
+    {
+        if (gTypeEffectiveness[i] == TYPE_FORESIGHT)
+        {
+            i += 3;
+            continue;
+        }
+        else if (gTypeEffectiveness[i] == atkType)
+        {
+            // check type1
+            if (gTypeEffectiveness[i + 1] == defType1)
+                *var = (*var * gTypeEffectiveness[i + 2]) / 10;
+            // check type2
+            if (gTypeEffectiveness[i + 1] == defType2 && defType1 != defType2)
+                *var = (*var * gTypeEffectiveness[i + 2]) / 10;
+        }
+        i += 3;
+    }
+}
+
+u8 GetMostSuitableMonToSwitchInto(void)
+{
+    u8 opposingBank;
+    u8 bestDmg; // note : should be changed to u32 for obvious reasons
+    u8 bestMonId;
+    u8 bankIn1, bankIn2;
+    s32 firstId;
+    s32 lastId; // + 1
+    struct Pokemon *party;
+    s32 i, j;
+    u8 invalidMons;
+    u16 move;
+
+    if (*(gBattleStruct->field_5C + gActiveBank) != 6)
+        return *(gBattleStruct->field_5C + gActiveBank);
+    if (gBattleTypeFlags & BATTLE_TYPE_ARENA)
+        return gBattlePartyID[gActiveBank] + 1;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+    {
+        bankIn1 = gActiveBank;
+        if (gAbsentBankFlags & gBitTable[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)])
+            bankIn2 = gActiveBank;
+        else
+            bankIn2 = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON);
+
+        // UB: It considers the opponent only player's side even though it can battle alongside player;
+        opposingBank = Random() & BIT_MON;
+        if (gAbsentBankFlags & gBitTable[opposingBank])
+            opposingBank ^= BIT_MON;
+    }
+    else
+    {
+        opposingBank = GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_SIDE);
+        bankIn1 = gActiveBank;
+        bankIn2 = gActiveBank;
+    }
+
+    if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000))
+    {
+        if ((gActiveBank & BIT_MON) == 0)
+            firstId = 0, lastId = 3;
+        else
+            firstId = 3, lastId = 6;
+    }
+    else
+    {
+        firstId = 0, lastId = 6;
+    }
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    invalidMons = 0;
+
+    while (invalidMons != 0x3F) // all mons are invalid
+    {
+        bestDmg = 0;
+        bestMonId = 6;
+        // find the mon which type is the most suitable offensively
+        for (i = firstId; i < lastId; i++)
+        {
+            u16 species = GetMonData(&party[i], MON_DATA_SPECIES);
+            if (species != SPECIES_NONE
+                && GetMonData(&party[i], MON_DATA_HP) != 0
+                && !(gBitTable[i] & invalidMons)
+                && gBattlePartyID[bankIn1] != i
+                && gBattlePartyID[bankIn2] != i
+                && i != *(gBattleStruct->field_5C + bankIn1)
+                && i != *(gBattleStruct->field_5C + bankIn2))
+            {
+                u8 type1 = gBaseStats[species].type1;
+                u8 type2 = gBaseStats[species].type2;
+                u8 typeDmg = 10;
+                ModulateByTypeEffectiveness(gBattleMons[opposingBank].type1, type1, type2, &typeDmg);
+                ModulateByTypeEffectiveness(gBattleMons[opposingBank].type2, type1, type2, &typeDmg);
+                if (bestDmg < typeDmg)
+                {
+                    bestDmg = typeDmg;
+                    bestMonId = i;
+                }
+            }
+            else
+            {
+                invalidMons |= gBitTable[i];
+            }
+        }
+
+        // ok, we know the mon has the right typing but does it have at least one super effective move?
+        if (bestMonId != 6)
+        {
+            for (i = 0; i < 4; i++)
+            {
+                move = GetMonData(&party[bestMonId], MON_DATA_MOVE1 + i);
+                if (move != MOVE_NONE && TypeCalc(move, gActiveBank, opposingBank) & MOVESTATUS_SUPEREFFECTIVE)
+                    break;
+            }
+
+            if (i != 4)
+                return bestMonId; // has both the typing and at least one super effective move
+
+            invalidMons |= gBitTable[bestMonId]; // sorry buddy, we want something better
+        }
+        else
+        {
+            invalidMons = 0x3F; // no viable mon to switch
+        }
+    }
+
+    gDynamicBasePower = 0;
+    gBattleStruct->dynamicMoveType = 0;
+    gBattleScripting.dmgMultiplier = 1;
+    gBattleMoveFlags = 0;
+    gCritMultiplier = 1;
+    bestDmg = 0;
+    bestMonId = 6;
+
+    // if we couldn't find the best mon in terms of typing, find the one that deals most damage
+    for (i = firstId; i < lastId; i++)
+    {
+        if ((u16)(GetMonData(&party[i], MON_DATA_SPECIES)) == SPECIES_NONE)
+            continue;
+        if (GetMonData(&party[i], MON_DATA_HP) == 0)
+            continue;
+        if (gBattlePartyID[bankIn1] == i)
+            continue;
+        if (gBattlePartyID[bankIn2] == i)
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn1))
+            continue;
+        if (i == *(gBattleStruct->field_5C + bankIn2))
+            continue;
+
+        for (j = 0; j < 4; j++)
+        {
+            move = GetMonData(&party[i], MON_DATA_MOVE1 + j);
+            gBattleMoveDamage = 0;
+            if (move != MOVE_NONE && gBattleMoves[move].power != 1)
+            {
+                AI_CalcDmg(gActiveBank, opposingBank);
+                TypeCalc(move, gActiveBank, opposingBank);
+            }
+            if (bestDmg < gBattleMoveDamage)
+            {
+                bestDmg = gBattleMoveDamage;
+                bestMonId = i;
+            }
+        }
+    }
+
+    return bestMonId;
+}
+
+// TODO: use PokemonItemEffect struct instead of u8 once it's documented
+static u8 GetAI_ItemType(u8 itemId, const u8 *itemEffect) // NOTE: should take u16 as item Id argument
+{
+    if (itemId == ITEM_FULL_RESTORE)
+        return AI_ITEM_FULL_RESTORE;
+    if (itemEffect[4] & 4)
+        return AI_ITEM_HEAL_HP;
+    if (itemEffect[3] & 0x3F)
+        return AI_ITEM_CURE_CONDITION;
+    if (itemEffect[0] & 0x3F || itemEffect[1] != 0 || itemEffect[2] != 0)
+        return AI_ITEM_X_STAT;
+    if (itemEffect[3] & 0x80)
+        return AI_ITEM_GUARD_SPECS;
+
+    return AI_ITEM_NOT_RECOGNIZABLE;
+}
+
+static bool8 ShouldUseItem(void)
+{
+    struct Pokemon *party;
+    s32 i;
+    u8 validMons = 0;
+    bool8 shouldUse = FALSE;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON2)
+        return FALSE;
+
+    if (GetBankSide(gActiveBank) == SIDE_PLAYER)
+        party = gPlayerParty;
+    else
+        party = gEnemyParty;
+
+    for (i = 0; i < 6; i++)
+    {
+        if (GetMonData(&party[i], MON_DATA_HP) != 0
+            && GetMonData(&party[i], MON_DATA_SPECIES2) != SPECIES_NONE
+            && GetMonData(&party[i], MON_DATA_SPECIES2) != SPECIES_EGG)
+        {
+            validMons++;
+        }
+    }
+
+    for (i = 0; i < 4; i++)
+    {
+        u16 item;
+        const u8 *itemEffects;
+        u8 paramOffset;
+        u8 bankSide;
+
+        if (i != 0 && validMons > (gBattleResources->battleHistory->itemsNo - i) + 1)
+            continue;
+        item = gBattleResources->battleHistory->trainerItems[i];
+        if (item == ITEM_NONE)
+            continue;
+        if (gItemEffectTable[item - 13] == NULL)
+            continue;
+
+        if (item == ITEM_ENIGMA_BERRY)
+            itemEffects = gSaveBlock1Ptr->enigmaBerry.itemEffect;
+        else
+            itemEffects = gItemEffectTable[item - 13];
+
+        *(gBattleStruct->AI_itemType + gActiveBank / 2) = GetAI_ItemType(item, itemEffects);
+
+        switch (*(gBattleStruct->AI_itemType + gActiveBank / 2))
+        {
+        case AI_ITEM_FULL_RESTORE:
+            if (gBattleMons[gActiveBank].hp >= gBattleMons[gActiveBank].maxHP / 4)
+                break;
+            if (gBattleMons[gActiveBank].hp == 0)
+                break;
+            shouldUse = TRUE;
+            break;
+        case AI_ITEM_HEAL_HP:
+            paramOffset = GetItemEffectParamOffset(item, 4, 4);
+            if (paramOffset == 0)
+                break;
+            if (gBattleMons[gActiveBank].hp == 0)
+                break;
+            if (gBattleMons[gActiveBank].hp < gBattleMons[gActiveBank].maxHP / 4 || gBattleMons[gActiveBank].maxHP - gBattleMons[gActiveBank].hp > itemEffects[paramOffset])
+                shouldUse = TRUE;
+            break;
+        case AI_ITEM_CURE_CONDITION:
+            *(gBattleStruct->AI_itemFlags + gActiveBank / 2) = 0;
+            if (itemEffects[3] & 0x20 && gBattleMons[gActiveBank].status1 & STATUS_SLEEP)
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x20;
+                shouldUse = TRUE;
+            }
+            if (itemEffects[3] & 0x10 && (gBattleMons[gActiveBank].status1 & STATUS_POISON || gBattleMons[gActiveBank].status1 & STATUS_TOXIC_POISON))
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x10;
+                shouldUse = TRUE;
+            }
+            if (itemEffects[3] & 0x8 && gBattleMons[gActiveBank].status1 & STATUS_BURN)
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x8;
+                shouldUse = TRUE;
+            }
+            if (itemEffects[3] & 0x4 && gBattleMons[gActiveBank].status1 & STATUS_FREEZE)
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x4;
+                shouldUse = TRUE;
+            }
+            if (itemEffects[3] & 0x2 && gBattleMons[gActiveBank].status1 & STATUS_PARALYSIS)
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x2;
+                shouldUse = TRUE;
+            }
+            if (itemEffects[3] & 0x1 && gBattleMons[gActiveBank].status2 & STATUS2_CONFUSION)
+            {
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x1;
+                shouldUse = TRUE;
+            }
+            break;
+        case AI_ITEM_X_STAT:
+            *(gBattleStruct->AI_itemFlags + gActiveBank / 2) = 0;
+            if (gDisableStructs[gActiveBank].isFirstTurn == 0)
+                break;
+            if (itemEffects[0] & 0xF)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x1;
+            if (itemEffects[1] & 0xF0)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x2;
+            if (itemEffects[1] & 0xF)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x4;
+            if (itemEffects[2] & 0xF)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x8;
+            if (itemEffects[2] & 0xF0)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x20;
+            if (itemEffects[0] & 0x30)
+                *(gBattleStruct->AI_itemFlags + gActiveBank / 2) |= 0x80;
+            shouldUse = TRUE;
+            break;
+        case AI_ITEM_GUARD_SPECS:
+            bankSide = GetBankSide(gActiveBank);
+            if (gDisableStructs[gActiveBank].isFirstTurn != 0 && gSideTimers[bankSide].mistTimer == 0)
+                shouldUse = TRUE;
+            break;
+        case AI_ITEM_NOT_RECOGNIZABLE:
+            return FALSE;
+        }
+
+        if (shouldUse)
+        {
+            EmitCmd33(1, 1, 0);
+            *(gBattleStruct->field_C0 + (gActiveBank / 2) * 2) = item;
+            gBattleResources->battleHistory->trainerItems[i] = 0;
+            return shouldUse;
+        }
+    }
+
+    return FALSE;
+}

src/battle_dome_cards.c

@@ -17,7 +17,7 @@ extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[];
 extern const union AffineAnimCmd *const gUnknown_082FF618[];
 extern const union AffineAnimCmd *const gUnknown_082FF694[];
 extern const union AnimCmd *const gUnknown_082FF70C[];
-extern const union AnimCmd *const *const gUnknown_08309AAC[NUM_SPECIES];
+extern const union AnimCmd *const *const gMonAnimationsSpriteAnimsPtrTable[NUM_SPECIES];
 extern const union AnimCmd *const *const gUnknown_0830536C[];
 extern const u8 gUnknown_0831F578[];
 
@@ -282,7 +282,7 @@ u16 sub_818D3E4(u16 species, u32 otId, u32 personality, u8 flags, s16 x, s16 y,
         images[j].size = 0x800;
     }
     gUnknown_0203CCEC.tileTag = 0xFFFF;
-    gUnknown_0203CCEC.anims = gUnknown_08309AAC[species];
+    gUnknown_0203CCEC.anims = gMonAnimationsSpriteAnimsPtrTable[species];
     gUnknown_0203CCEC.images = images;
     if (flags2 == 0x01)
     {

src/berry_blender.c

@@ -0,0 +1,18 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+IWRAM_DATA void *berry_blender_c_unused_03000de4;
+IWRAM_DATA s16 gUnknown_03000DE8[8];
+IWRAM_DATA s16 gUnknown_03000DF8[6];
+IWRAM_DATA s16 gUnknown_03000E04;
+IWRAM_DATA s16 gUnknown_03000E06;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/braille_puzzles.c

@@ -0,0 +1,583 @@
+#include "global.h"
+#include "event_data.h"
+#include "songs.h"
+#include "sound.h"
+#include "script.h"
+#include "species.h"
+#include "task.h"
+#include "field_effect.h"
+#include "flags.h"
+
+extern void MapGridSetMetatileIdAt(s32 x, s32 y, u16 metatileId); // fieldmap
+extern void DrawWholeMapView(); // field_camera
+extern void SetCameraPanningCallback(void ( *callback)()); // field_camera
+extern void InstallCameraPanAheadCallback(void);
+extern void SetCameraPanning(s16 x, s16 y);
+extern u8 brm_get_pokemon_selection(void);
+extern void FieldEffectActiveListRemove(u8 id); // field_effect
+extern u8 oei_task_add(void);
+
+// why do this, GF?
+enum
+{
+    STRENGTH_PUZZLE,
+    FLY_PUZZLE
+};
+
+extern u8 gBraillePuzzleCallbackFlag;
+extern u8 gUnknown_085EFE74[][2];
+
+void SealedChamberShakingEffect(u8);
+void sub_8179860(void);
+void sub_8179944(void);
+
+bool8 ShouldDoBrailleDigEffect(void)
+{
+    if (!FlagGet(SYS_BRAILLE_DIG)
+     && (gSaveBlock1Ptr->location.mapGroup == 0x18
+     && gSaveBlock1Ptr->location.mapNum == 0x47))
+    {
+        if (gSaveBlock1Ptr->pos.x == 10 && gSaveBlock1Ptr->pos.y == 3)
+            return TRUE;
+        if (gSaveBlock1Ptr->pos.x == 9 && gSaveBlock1Ptr->pos.y == 3)
+            return TRUE;
+        if (gSaveBlock1Ptr->pos.x == 11 && gSaveBlock1Ptr->pos.y == 3)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+void DoBrailleDigEffect(void)
+{
+    MapGridSetMetatileIdAt(16, 8, 554);
+    MapGridSetMetatileIdAt(17, 8, 555);
+    MapGridSetMetatileIdAt(18, 8, 556);
+    MapGridSetMetatileIdAt(16, 9, 3634);
+    MapGridSetMetatileIdAt(17, 9, 563);
+    MapGridSetMetatileIdAt(18, 9, 3636);
+    DrawWholeMapView();
+    PlaySE(SE_BAN);
+    FlagSet(SYS_BRAILLE_DIG);
+    ScriptContext2_Disable();
+}
+
+bool8 CheckRelicanthWailord(void)
+{
+    // Emerald change: why did they flip it?
+    // First comes Wailord
+    if (GetMonData(&gPlayerParty[0], MON_DATA_SPECIES2, 0) == SPECIES_WAILORD)
+    {
+        CalculatePlayerPartyCount();
+        // Last comes Relicanth
+        if (GetMonData(&gPlayerParty[gPlayerPartyCount - 1], MON_DATA_SPECIES2, 0) == SPECIES_RELICANTH)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+// THEORY: this was caused by block commenting out all of the older R/S braille functions but leaving the call to it itself, which creates the nullsub.
+// the code is shown below to show what this might look like.
+void ShouldDoBrailleStrengthEffectOld(void)
+{
+    /*
+        if (!FlagGet(SYS_BRAILLE_STRENGTH) && (gSaveBlock1.location.mapGroup == MAP_GROUP_DESERT_RUINS && gSaveBlock1.location.mapNum == MAP_ID_DESERT_RUINS))
+    {
+        if (gSaveBlock1.pos.x == 10 && gSaveBlock1.pos.y == 23)
+            return TRUE;
+        else if (gSaveBlock1.pos.x == 9 && gSaveBlock1.pos.y == 23)
+            return TRUE;
+        else if (gSaveBlock1.pos.x == 11 && gSaveBlock1.pos.y == 23)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+void DoBrailleStrengthEffect(void)
+{
+    FieldEffectActiveListRemove(FLDEFF_USE_STRENGTH);
+    MapGridSetMetatileIdAt(14, 26, 554);
+    MapGridSetMetatileIdAt(15, 26, 555);
+    MapGridSetMetatileIdAt(16, 26, 556);
+    MapGridSetMetatileIdAt(14, 27, 3634);
+    MapGridSetMetatileIdAt(15, 27, 563);
+    MapGridSetMetatileIdAt(16, 27, 3636);
+    DrawWholeMapView();
+    PlaySE(SE_BAN);
+    FlagSet(SYS_BRAILLE_STRENGTH);
+    ScriptContext2_Disable();
+}
+
+bool8 ShouldDoBrailleFlyEffect(void)
+{
+    if (!FlagGet(SYS_BRAILLE_FLY) && (gSaveBlock1.location.mapGroup == MAP_GROUP_ANCIENT_TOMB && gSaveBlock1.location.mapNum == MAP_ID_ANCIENT_TOMB))
+    {
+        if (gSaveBlock1.pos.x == 8 && gSaveBlock1.pos.y == 25)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+void DoBrailleFlyEffect(void)
+{
+    gFieldEffectArguments[0] = gLastFieldPokeMenuOpened;
+    FieldEffectStart(FLDEFF_USE_FLY_ANCIENT_TOMB);
+}
+
+bool8 FldEff_UseFlyAncientTomb(void)
+{
+    u8 taskId = oei_task_add();
+
+    gTasks[taskId].data[8] = (u32)UseFlyAncientTomb_Callback >> 16;
+    gTasks[taskId].data[9] = (u32)UseFlyAncientTomb_Callback;
+    return FALSE;
+}
+
+void UseFlyAncientTomb_Callback(void)
+{
+    FieldEffectActiveListRemove(FLDEFF_USE_FLY_ANCIENT_TOMB);
+    UseFlyAncientTomb_Finish();
+}
+
+void UseFlyAncientTomb_Finish(void)
+{
+    MapGridSetMetatileIdAt(14, 26, 554);
+    MapGridSetMetatileIdAt(15, 26, 555);
+    MapGridSetMetatileIdAt(16, 26, 556);
+    MapGridSetMetatileIdAt(14, 27, 3634);
+    MapGridSetMetatileIdAt(15, 27, 563);
+    MapGridSetMetatileIdAt(16, 27, 3636);
+    DrawWholeMapView();
+    PlaySE(SE_BAN);
+    FlagSet(SYS_BRAILLE_FLY);
+    ScriptContext2_Disable();
+}
+    */
+}
+
+void DoSealedChamberShakingEffect1(void)
+{
+    u8 taskId = CreateTask(SealedChamberShakingEffect, 9);
+
+    gTasks[taskId].data[1] = 0;
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].data[4] = 2;
+    gTasks[taskId].data[5] = 5;
+    gTasks[taskId].data[6] = 50;
+    SetCameraPanningCallback(0);
+}
+
+void DoSealedChamberShakingEffect2(void)
+{
+    u8 taskId = CreateTask(SealedChamberShakingEffect, 9);
+
+    gTasks[taskId].data[1] = 0;
+    gTasks[taskId].data[2] = 0;
+    gTasks[taskId].data[4] = 3;
+    gTasks[taskId].data[5] = 5;
+    gTasks[taskId].data[6] = 2;
+    SetCameraPanningCallback(0);
+}
+
+void SealedChamberShakingEffect(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+
+    task->data[1]++;
+
+    if (!(task->data[1] % task->data[5]))
+    {
+        task->data[1] = 0;
+        task->data[2]++;
+        task->data[4] = -task->data[4];
+        SetCameraPanning(0, task->data[4]);
+        if (task->data[2] == task->data[6])
+        {
+            DestroyTask(taskId);
+            EnableBothScriptContexts();
+            InstallCameraPanAheadCallback();
+        }
+    }
+}
+
+// moved later in the function because it was rewritten.
+bool8 ShouldDoBrailleStrengthEffect(void)
+{
+    if (!FlagGet(SYS_BRAILLE_STRENGTH) && (gSaveBlock1Ptr->location.mapGroup == 0x18 && gSaveBlock1Ptr->location.mapNum == 0x06))
+    {
+        if (gSaveBlock1Ptr->pos.x == 6 && gSaveBlock1Ptr->pos.y == 23)
+            { gBraillePuzzleCallbackFlag = STRENGTH_PUZZLE; return TRUE; }
+        else if (gSaveBlock1Ptr->pos.x == 5 && gSaveBlock1Ptr->pos.y == 23)
+            { gBraillePuzzleCallbackFlag = STRENGTH_PUZZLE; return TRUE; }
+        else if (gSaveBlock1Ptr->pos.x == 7 && gSaveBlock1Ptr->pos.y == 23)
+            { gBraillePuzzleCallbackFlag = STRENGTH_PUZZLE; return TRUE; }
+    }
+
+    return FALSE;
+}
+
+void sub_8179834(void)
+{
+    gFieldEffectArguments[0] = brm_get_pokemon_selection();
+    FieldEffectStart(FLDEFF_USE_FLY_ANCIENT_TOMB);
+}
+
+void UseStrengthDesertRuins_Callback(void)
+{
+    FieldEffectActiveListRemove(FLDEFF_USE_FLY_ANCIENT_TOMB);
+    sub_8179860();
+}
+
+void sub_8179860(void)
+{
+    MapGridSetMetatileIdAt(14, 26, 554);
+    MapGridSetMetatileIdAt(15, 26, 555);
+    MapGridSetMetatileIdAt(16, 26, 556);
+    MapGridSetMetatileIdAt(14, 27, 3634);
+    MapGridSetMetatileIdAt(15, 27, 563);
+    MapGridSetMetatileIdAt(16, 27, 3636);
+    DrawWholeMapView();
+    PlaySE(SE_BAN);
+    FlagSet(SYS_BRAILLE_STRENGTH);
+    ScriptContext2_Disable();
+}
+
+bool8 ShouldDoBrailleFlyEffect(void)
+{
+    if (!FlagGet(SYS_BRAILLE_FLY) && (gSaveBlock1Ptr->location.mapGroup == 0x18 && gSaveBlock1Ptr->location.mapNum == 0x44))
+    {
+        if (gSaveBlock1Ptr->pos.x == 8 && gSaveBlock1Ptr->pos.y == 25)
+            { gBraillePuzzleCallbackFlag = FLY_PUZZLE; return TRUE; }
+    }
+    return FALSE;
+}
+
+void sub_8179918(void)
+{
+    gFieldEffectArguments[0] = brm_get_pokemon_selection();
+    FieldEffectStart(FLDEFF_USE_FLY_ANCIENT_TOMB);
+}
+
+void UseFlyAncientTomb_Callback(void)
+{
+    FieldEffectActiveListRemove(FLDEFF_USE_FLY_ANCIENT_TOMB);
+    sub_8179944();
+}
+
+void sub_8179944(void)
+{
+    MapGridSetMetatileIdAt(14, 26, 554);
+    MapGridSetMetatileIdAt(15, 26, 555);
+    MapGridSetMetatileIdAt(16, 26, 556);
+    MapGridSetMetatileIdAt(14, 27, 3634);
+    MapGridSetMetatileIdAt(15, 27, 563);
+    MapGridSetMetatileIdAt(16, 27, 3636);
+    DrawWholeMapView();
+    PlaySE(SE_BAN);
+    FlagSet(SYS_BRAILLE_FLY);
+    ScriptContext2_Disable();
+}
+
+// theory: another commented out DoBrailleWait and Task_BrailleWait.
+void DoBrailleWait(void)
+{
+    /*
+    if (!FlagGet(SYS_BRAILLE_WAIT))
+        CreateTask(Task_BrailleWait, 0x50);
+}
+
+void Task_BrailleWait(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+    case 0:
+        data[1] = 7200;
+        data[0] = 1;
+        break;
+    case 1:
+        if (BrailleWait_CheckButtonPress() != FALSE)
+        {
+            MenuZeroFillScreen();
+            PlaySE(SE_SELECT);
+            data[0] = 2;
+        }
+        else
+        {
+            data[1] = data[1] - 1;
+            if (data[1] == 0)
+            {
+                MenuZeroFillScreen();
+                data[0] = 3;
+                data[1] = 30;
+            }
+        }
+        break;
+    case 2:
+        if (BrailleWait_CheckButtonPress() == FALSE)
+        {
+            data[1] = data[1] - 1;
+            if (data[1] == 0)
+                data[0] = 4;
+            break;
+        }
+        sub_8064E2C();
+        DestroyTask(taskId);
+        ScriptContext2_Disable();
+        break;
+    case 3:
+        data[1] = data[1] - 1;
+        if (data[1] == 0)
+            data[0] = 4;
+        break;
+    case 4:
+        sub_8064E2C();
+        ScriptContext1_SetupScript(S_OpenRegiceChamber);
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+bool32 BrailleWait_CheckButtonPress(void)
+{
+    u16 keyMask = A_BUTTON | B_BUTTON | START_BUTTON | SELECT_BUTTON | DPAD_ANY;
+
+    if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_LR)
+        keyMask |= L_BUTTON | R_BUTTON;
+    if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A)
+        keyMask |= L_BUTTON;
+
+    if (gMain.newKeys & keyMask)
+        return TRUE;
+    else
+        return FALSE;
+    */
+}
+
+// this used to be FldEff_UseFlyAncientTomb . why did GF merge the 2 functions?
+bool8 FldEff_UsePuzzleEffect(void)
+{
+    u8 taskId = oei_task_add();
+
+    if (gBraillePuzzleCallbackFlag == FLY_PUZZLE)
+    {
+        gTasks[taskId].data[8] = (u32)UseFlyAncientTomb_Callback >> 16;
+        gTasks[taskId].data[9] = (u32)UseFlyAncientTomb_Callback;
+    }
+    else
+    {
+        gTasks[taskId].data[8] = (u32)UseStrengthDesertRuins_Callback >> 16;
+        gTasks[taskId].data[9] = (u32)UseStrengthDesertRuins_Callback;
+    }
+    return FALSE;
+}
+
+// can't get this one to match due to the weird macro-like varsets with strange bitshifting.
+// to note: 0x10000 is loaded in, and its obviously supposed to be 1, but i cant get 0x80 << 9 to be loaded in without using it directly.
+// maybe there's some way of writing it that works?
+#ifdef NONMATCHING
+// ShouldDoBrailleRegicePuzzle
+bool8 ShouldDoBrailleRegicePuzzle(void)
+{
+    u8 i;
+
+    if (gSaveBlock1Ptr->location.mapGroup == 0x18 && gSaveBlock1Ptr->location.mapNum == 0x43)
+    {
+        // _08179A1A
+        if (FlagGet(SYS_BRAILLE_WAIT) != FALSE)
+            return FALSE;
+        if (FlagGet(2) == FALSE)
+            return FALSE;
+        if (FlagGet(3) == TRUE)
+            return FALSE;
+
+        for (i = 0; i < 36; i++)
+        {
+            if (gSaveBlock1Ptr->pos.x == gUnknown_085EFE74[i][0] && gSaveBlock1Ptr->pos.y == gUnknown_085EFE74[i][1])
+            {
+                if (i < 16)
+                    VarSet(0x403B, (0x10000 << i | VarGet(0x403B) << 16) >> 16); // correct
+                else if (i < 32)
+                    VarSet(0x403C, (0x10000 << (i - 16) | VarGet(0x403C) << 16) >> 16); // hmm?
+                else
+                    VarSet(0x403D, (0x10000 << (i - 32) | VarGet(0x403D) << 16) >> 16); // hmm?
+
+                if (VarGet(0x403B) != 0xFFFF || VarGet(0x403C) != 0xFF || VarGet(0x403D) != 0xF)
+                    return FALSE;
+
+                if (gSaveBlock1Ptr->pos.x == 8 && gSaveBlock1Ptr->pos.y == 21)
+                    return TRUE;
+                else
+                    return FALSE;
+            }
+        }
+    }
+    // TODO: Find what flags 2 and 3 are.
+    FlagSet(3);
+    FlagClear(2);
+    return FALSE;
+}
+#else
+__attribute__((naked))
+bool8 ShouldDoBrailleRegicePuzzle(void)
+{
+    asm(".syntax unified\n\
+    push {r4-r7,lr}\n\
+    mov r7, r9\n\
+    mov r6, r8\n\
+    push {r6,r7}\n\
+    ldr r4, =gSaveBlock1Ptr\n\
+    ldr r0, [r4]\n\
+    ldrh r1, [r0, 0x4]\n\
+    ldr r0, =0x00004318\n\
+    cmp r1, r0\n\
+    beq _08179A1A\n\
+    b _08179B5A\n\
+_08179A1A:\n\
+    ldr r0, =0x000008b1\n\
+    bl FlagGet\n\
+    lsls r0, 24\n\
+    cmp r0, 0\n\
+    beq _08179A28\n\
+    b _08179B5A\n\
+_08179A28:\n\
+    movs r0, 0x2\n\
+    bl FlagGet\n\
+    lsls r0, 24\n\
+    cmp r0, 0\n\
+    bne _08179A36\n\
+    b _08179B5A\n\
+_08179A36:\n\
+    movs r0, 0x3\n\
+    bl FlagGet\n\
+    lsls r0, 24\n\
+    lsrs r0, 24\n\
+    cmp r0, 0x1\n\
+    bne _08179A58\n\
+    b _08179B5A\n\
+    .pool\n\
+_08179A54:\n\
+    movs r0, 0x1\n\
+    b _08179B5C\n\
+_08179A58:\n\
+    movs r5, 0\n\
+    mov r8, r4\n\
+    ldr r4, =gUnknown_085EFE74\n\
+    adds r0, r4, 0x1\n\
+    mov r12, r0\n\
+    ldr r6, =0x0000403b\n\
+    ldr r1, =0x0000403c\n\
+    mov r9, r1\n\
+_08179A68:\n\
+    lsls r0, r5, 1\n\
+    adds r1, r0, r4\n\
+    add r0, r12\n\
+    ldrb r3, [r0]\n\
+    mov r7, r8\n\
+    ldr r2, [r7]\n\
+    movs r7, 0\n\
+    ldrsh r0, [r2, r7]\n\
+    ldrb r1, [r1]\n\
+    cmp r0, r1\n\
+    bne _08179B44\n\
+    movs r1, 0x2\n\
+    ldrsh r0, [r2, r1]\n\
+    cmp r0, r3\n\
+    bne _08179B44\n\
+    cmp r5, 0xF\n\
+    bhi _08179AB0\n\
+    adds r0, r6, 0\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    movs r1, 0x80\n\
+    lsls r1, 9\n\
+    lsls r1, r5\n\
+    orrs r1, r0\n\
+    lsrs r1, 16\n\
+    adds r0, r6, 0\n\
+    bl VarSet\n\
+    b _08179AF0\n\
+    .pool\n\
+_08179AB0:\n\
+    cmp r5, 0x1F\n\
+    bhi _08179AD2\n\
+    mov r0, r9\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    adds r2, r5, 0\n\
+    subs r2, 0x10\n\
+    movs r1, 0x80\n\
+    lsls r1, 9\n\
+    lsls r1, r2\n\
+    orrs r1, r0\n\
+    lsrs r1, 16\n\
+    mov r0, r9\n\
+    bl VarSet\n\
+    b _08179AF0\n\
+_08179AD2:\n\
+    ldr r4, =0x0000403d\n\
+    adds r0, r4, 0\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    adds r2, r5, 0\n\
+    subs r2, 0x20\n\
+    movs r1, 0x80\n\
+    lsls r1, 9\n\
+    lsls r1, r2\n\
+    orrs r1, r0\n\
+    lsrs r1, 16\n\
+    adds r0, r4, 0\n\
+    bl VarSet\n\
+_08179AF0:\n\
+    ldr r0, =0x0000403b\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    lsrs r4, r0, 16\n\
+    ldr r0, =0x0000ffff\n\
+    cmp r4, r0\n\
+    bne _08179B5A\n\
+    ldr r0, =0x0000403c\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    lsrs r0, 16\n\
+    cmp r0, r4\n\
+    bne _08179B5A\n\
+    ldr r0, =0x0000403d\n\
+    bl VarGet\n\
+    lsls r0, 16\n\
+    lsrs r0, 16\n\
+    cmp r0, 0xF\n\
+    bne _08179B5A\n\
+    ldr r0, =gSaveBlock1Ptr\n\
+    ldr r0, [r0]\n\
+    ldr r1, [r0]\n\
+    ldr r0, =0x00150008\n\
+    cmp r1, r0\n\
+    beq _08179A54\n\
+    b _08179B5A\n\
+    .pool\n\
+_08179B44:\n\
+    adds r0, r5, 0x1\n\
+    lsls r0, 24\n\
+    lsrs r5, r0, 24\n\
+    cmp r5, 0x23\n\
+    bls _08179A68\n\
+    movs r0, 0x3\n\
+    bl FlagSet\n\
+    movs r0, 0x2\n\
+    bl FlagClear\n\
+_08179B5A:\n\
+    movs r0, 0\n\
+_08179B5C:\n\
+    pop {r3,r4}\n\
+    mov r8, r3\n\
+    mov r9, r4\n\
+    pop {r4-r7}\n\
+    pop {r1}\n\
+    bx r1\n\
+    .syntax divided");
+}
+#endif

src/calculate_base_damage.c

@@ -19,7 +19,6 @@ extern struct BattleEnigmaBerry gEnigmaBerries[];
 extern u16 gBattleMovePower;
 extern u16 gTrainerBattleOpponent_A;
 
-u8 CountAliveMonsInBattle(u8);
 bool8 ShouldGetStatBadgeBoost(u16 flagId, u8 bank);
 
 extern const struct BattleMove gBattleMoves[];

src/clear_save_data_screen.c

@@ -0,0 +1,209 @@
+#include "global.h"
+#include "task.h"
+#include "menu.h"
+#include "text.h"
+#include "sound.h"
+#include "main.h"
+#include "save.h"
+#include "palette.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "text_window.h"
+#include "songs.h"
+
+extern u8 gText_ClearAllSaveData[];
+extern u8 gText_ClearingData[];
+
+extern u16 gUnknown_0860F074[];
+
+static void Task_DoClearSaveDataScreenYesNo(u8);
+static void Task_ClearSaveDataScreenYesNoChoice(u8);
+static void Task_ClearSaveData(u8);
+static bool8 SetupClearSaveDataScreen(void);
+static void CB2_FadeAndDoReset(void);
+static void InitClearSaveDataScreenWindows(void);
+
+static const struct BgTemplate sClearSaveBgTemplates[2] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0,
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0,
+    },
+};
+
+static const struct WindowTemplate sClearSaveTextWindow[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 3,
+        .tilemapTop = 15,
+        .width = 26,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 11,
+    },
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sClearSaveYesNo[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 3,
+        .tilemapTop = 2,
+        .width = 5,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 115,
+    }
+};
+
+void CB2_InitClearSaveDataScreen(void)
+{
+    if(SetupClearSaveDataScreen())
+        CreateTask(Task_DoClearSaveDataScreenYesNo, 0);
+}
+
+static void Task_DoClearSaveDataScreenYesNo(u8 taskId)
+{
+    SetWindowBorderStyle(0, 0, 2, 14);
+    PrintTextOnWindow(0, 1, gText_ClearAllSaveData, 0, 1, 0, 0);
+    CreateYesNoMenu(sClearSaveYesNo, 2, 14, 1);
+    gTasks[taskId].func = Task_ClearSaveDataScreenYesNoChoice;
+}
+
+static void Task_ClearSaveDataScreenYesNoChoice(u8 taskId)
+{
+    switch(sub_8198C58())
+    {
+        case 0:
+            FillWindowPixelBuffer(0, 17);
+            PrintTextOnWindow(0, 1, gText_ClearingData, 0, 1, 0, 0);
+            gTasks[taskId].func = Task_ClearSaveData;
+            break;
+        case 1:
+        case -1:
+            PlaySE(SE_SELECT);
+            DestroyTask(taskId);
+            SetMainCallback2(CB2_FadeAndDoReset);
+    }
+}
+
+static void Task_ClearSaveData(u8 taskId)
+{
+    ClearSaveData();
+    DestroyTask(taskId);
+    SetMainCallback2(CB2_FadeAndDoReset);
+}
+
+static void MainCB(void)
+{
+    RunTasks();
+    UpdatePaletteFade();
+}
+
+static void VBlankCB(void)
+{
+    TransferPlttBuffer();
+}
+
+static bool8 SetupClearSaveDataScreen(void)
+{
+    u16 i;
+
+    switch(gMain.state)
+    {
+        case 0:
+        default:
+            SetVBlankCallback(NULL);
+            SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0);
+            SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+            SetGpuReg(REG_OFFSET_WIN0H, 0);
+            SetGpuReg(REG_OFFSET_WIN0V, 0);
+            SetGpuReg(REG_OFFSET_WININ, 0);
+            SetGpuReg(REG_OFFSET_WINOUT, 0);
+            SetGpuReg(REG_OFFSET_BLDCNT, 0);
+            SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+            SetGpuReg(REG_OFFSET_BLDY, 0);
+            DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE);
+            DmaFill32(3, 0, (void *)OAM, OAM_SIZE);
+            DmaFill16(3, 0, (void *)(PLTT + 2), PLTT_SIZE - 2);
+            ResetPaletteFade();
+            gPlttBufferUnfaded[0] = 0x7fff;
+            gPlttBufferFaded[0] = 0x7fff;
+            gPlttBufferUnfaded[1] = 0x3945;
+            gPlttBufferFaded[1] = 0x3945;
+            for (i = 0; i < 0x10; i++)
+                ((u16 *)(VRAM + 0x20))[i] = 0x1111;
+
+            for (i = 0; i < 0x400; i++)
+                ((u16 *)(VRAM + 0xF000))[i] = 0x0001;
+            ResetTasks();
+            ResetSpriteData();
+            ResetBgsAndClearDma3BusyFlags(0);
+            InitBgsFromTemplates(0, sClearSaveBgTemplates, ARRAY_COUNT(sClearSaveBgTemplates));
+            SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+            ShowBg(0);
+            ShowBg(3);
+            SetGpuReg(REG_OFFSET_BLDCNT, 0);
+            InitClearSaveDataScreenWindows();
+            BeginNormalPaletteFade(0x0000FFFF, 0, 0x10, 0, 0xFFFF);
+            EnableInterrupts(1);
+            SetVBlankCallback(VBlankCB);
+            gMain.state = 1;
+            break;
+        case 1:
+            UpdatePaletteFade();
+            if(!gPaletteFade.active)
+            {
+                SetMainCallback2(MainCB);
+                return TRUE;
+            }
+    }
+    return FALSE;
+}
+
+static void CB2_FadeAndDoReset(void)
+{
+    switch(gMain.state)
+    {
+        case 0:
+        default:
+            BeginNormalPaletteFade(0x0000FFFF, 0, 0, 0x10, 0xFFFF);
+            gMain.state = 1;
+            break;
+        case 1:
+            UpdatePaletteFade();
+            if(!gPaletteFade.active)
+            {
+                FreeAllWindowBuffers();
+                DoSoftReset();
+            }
+    }
+}
+
+static void InitClearSaveDataScreenWindows(void)
+{
+    InitWindows(sClearSaveTextWindow);
+    DeactivateAllTextPrinters();
+    FillWindowPixelBuffer(0, 0);
+    sub_80987D4(0, 0, 2, 224);
+    LoadPalette(gUnknown_0860F074, 0xF0, 0x20);
+}

src/coins.c

@@ -4,14 +4,13 @@
 #include "window.h"
 #include "text_window.h"
 #include "string_util.h"
+#include "menu.h"
+#include "international_string_util.h"
 
 #define MAX_COINS 9999
 
 EWRAM_DATA u8 sCoinsWindowId = 0;
 
-extern s32 GetStringRightAlignXOffset(u8 fontId, u8 *str, s32 totalWidth);
-extern void SetWindowTemplateFields(struct WindowTemplate* template, u8 priority, u8 tilemapLeft, u8 tilemapTop, u8 width, u8 height, u8 palNum, u16 baseBlock);
-extern void SetWindowBorderStyle(u8 windowId, bool8 copyToVram, s16 tileStart, s8 palette);
 extern void sub_819746C(u8 windowId, bool8 copyToVram);
 
 extern const u8 gText_Coins[];
@@ -55,7 +54,7 @@ void SetCoins(u16 coinAmount)
 }
 
 /* Can't match it lol
-bool8 AddCoins(u16 toAdd)
+bool8 GiveCoins(u16 toAdd)
 {
     u16 newAmount;
     u16 ownedCoins = GetCoins();

src/decompress.c

@@ -465,7 +465,7 @@ u32 sub_8034974(void* ptr)
     return (ptr_[3] << 16) | (ptr_[2] << 8) | (ptr_[1]);
 }
 
-bool8 LoadCompressedObjectPicUsingHeap(struct CompressedSpriteSheet* src)
+bool8 LoadCompressedObjectPicUsingHeap(const struct CompressedSpriteSheet* src)
 {
     struct SpriteSheet dest;
     void* buffer;

src/decoration_inventory.c

@@ -0,0 +1,189 @@
+
+// Includes
+#include "global.h"
+#include "decoration.h"
+#include "decoration_inventory.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+EWRAM_DATA struct DecorationInventory gDecorationInventories[8] = {};
+
+// Static ROM declarations
+
+// .rodata
+
+// .text
+
+#define SET_DECOR_INV(i, ptr) {\
+    gDecorationInventories[i].items = ptr;\
+    gDecorationInventories[i].size = sizeof(ptr);\
+}
+
+void SetDecorationInventoriesPointers(void)
+{
+    SET_DECOR_INV(0, gSaveBlock1Ptr->decorDesk);
+    SET_DECOR_INV(1, gSaveBlock1Ptr->decorChair);
+    SET_DECOR_INV(2, gSaveBlock1Ptr->decorPlant);
+    SET_DECOR_INV(3, gSaveBlock1Ptr->decorOrnament);
+    SET_DECOR_INV(4, gSaveBlock1Ptr->decorMat);
+    SET_DECOR_INV(5, gSaveBlock1Ptr->decorPoster);
+    SET_DECOR_INV(6, gSaveBlock1Ptr->decorDoll);
+    SET_DECOR_INV(7, gSaveBlock1Ptr->decorCushion);
+    sub_8126968();
+}
+
+static void ClearDecorationInventory(u8 idx)
+{
+    u8 i;
+
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        gDecorationInventories[idx].items[i] = DECOR_NONE;
+    }
+}
+
+void ClearDecorationInventories(void)
+{
+    u8 idx;
+
+    for (idx = 0; idx < 8; idx ++)
+    {
+        ClearDecorationInventory(idx);
+    }
+}
+
+s8 GetFirstEmptyDecorSlot(u8 idx)
+{
+    s8 i;
+
+    for (i = 0; i < (s8)gDecorationInventories[idx].size; i ++)
+    {
+        if (gDecorationInventories[idx].items[i] == DECOR_NONE)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+bool8 CheckHasDecoration(u8 decor)
+{
+    u8 i;
+    u8 category;
+
+    category = gDecorations[decor].category;
+    for (i = 0; i < gDecorationInventories[category].size; i ++)
+    {
+        if (gDecorationInventories[category].items[i] == decor)
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+bool8 DecorationAdd(u8 decor)
+{
+    u8 category;
+    s8 idx;
+
+    if (decor == DECOR_NONE)
+    {
+        return FALSE;
+    }
+    category = gDecorations[decor].category;
+    idx = GetFirstEmptyDecorSlot(category);
+    if (idx == -1)
+    {
+        return FALSE;
+    }
+    gDecorationInventories[category].items[idx] = decor;
+    return TRUE;
+}
+
+bool8 DecorationCheckSpace(u8 decor)
+{
+    if (decor == DECOR_NONE)
+    {
+        return FALSE;
+    }
+    if (GetFirstEmptyDecorSlot(gDecorations[decor].category) == -1)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+s8 DecorationRemove(u8 decor)
+{
+    u8 i;
+    u8 idx;
+
+    i = 0;
+    if (decor == DECOR_NONE)
+    {
+        return 0;
+    }
+    for (i = 0; i < gDecorationInventories[gDecorations[decor].category].size; i ++)
+    {
+        idx = gDecorations[decor].category;
+        if (gDecorationInventories[idx].items[i] == decor)
+        {
+            gDecorationInventories[idx].items[i] = DECOR_NONE;
+            CondenseDecorationCategoryN(idx);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void CondenseDecorationCategoryN(u8 idx)
+{
+    u8 i;
+    u8 j;
+    u8 tmp;
+
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        for (j = i + 1; j < gDecorationInventories[idx].size; j ++)
+        {
+            if (gDecorationInventories[idx].items[j] != DECOR_NONE && (gDecorationInventories[idx].items[i] == DECOR_NONE || gDecorationInventories[idx].items[i] > gDecorationInventories[idx].items[j]))
+            {
+                tmp = gDecorationInventories[idx].items[i];
+                gDecorationInventories[idx].items[i] = gDecorationInventories[idx].items[j];
+                gDecorationInventories[idx].items[j] = tmp;
+            }
+        }
+    }
+}
+
+u8 CountDecorationCategoryN(u8 idx)
+{
+    u8 i;
+    u8 ct;
+
+    ct = 0;
+    for (i = 0; i < gDecorationInventories[idx].size; i ++)
+    {
+        if (gDecorationInventories[idx].items[i] != DECOR_NONE)
+        {
+            ct ++;
+        }
+    }
+    return ct;
+}
+
+u8 CountDecorations(void)
+{
+    u8 idx;
+    u8 ct;
+
+    ct = 0;
+    for (idx = 0; idx < 8; idx ++)
+    {
+        ct += CountDecorationCategoryN(idx);
+    }
+    return ct;
+}

src/diploma.c

@@ -0,0 +1,219 @@
+#include "global.h"
+#include "diploma.h"
+#include "palette.h"
+#include "main.h"
+#include "gpu_regs.h"
+#include "unknown_task.h"
+#include "task.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "bg.h"
+#include "window.h"
+#include "string_util.h"
+#include "text.h"
+
+extern void reset_temp_tile_data_buffers(void);
+extern int decompress_and_copy_tile_data_to_vram(u8 bg_id, void *src, int size, u16 offset, u8 mode);
+extern bool8 free_temp_tile_data_buffers_if_possible(void);
+extern void sub_80861E8(void); // rom4
+extern bool16 sub_80C0944(void);
+extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor *color, s8 speed, u8 *str);
+
+extern u16 gUnknown_0860F074[];
+
+extern u8 gText_DexNational[];
+extern u8 gText_DexHoenn[];
+extern u8 gText_PokedexDiploma[];
+
+static void MainCB2(void);
+static void Task_DiplomaFadeIn(u8);
+static void Task_DiplomaWaitForKeyPress(u8);
+static void Task_DiplomaFadeOut(u8);
+static void DisplayDiplomaText(void);
+static void InitDiplomaBg(void);
+static void InitDiplomaWindow(void);
+static void PrintDiplomaText(u8 *, u8, u8);
+
+EWRAM_DATA static void **sDiplomaTilemapPtr = {NULL};
+
+static void VBlankCB(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static const u16 sDiplomaPalettes[][16] =
+{
+    INCBIN_U16("graphics/misc/diploma_national.gbapal"),
+    INCBIN_U16("graphics/misc/diploma_hoenn.gbapal"),
+};
+
+static const u8 sDiplomaTilemap[] = INCBIN_U8("graphics/misc/diploma_map.bin.lz");
+static const u8 sDiplomaTiles[] = INCBIN_U8("graphics/misc/diploma.4bpp.lz");
+
+void CB2_ShowDiploma(void)
+{
+    SetVBlankCallback(NULL);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG3CNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG2CNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG1CNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG0CNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG3HOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG3VOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG2HOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG2VOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG1HOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG1VOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG0HOFS, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BG0VOFS, DISPCNT_MODE_0);
+    // why doesn't this one use the dma manager either?
+    DmaFill16(3, 0, VRAM, VRAM_SIZE);
+    DmaFill32(3, 0, OAM, OAM_SIZE);
+    DmaFill16(3, 0, PLTT, PLTT_SIZE);
+    remove_some_task();
+    ResetTasks();
+    ResetSpriteData();
+    ResetPaletteFade();
+    FreeAllSpritePalettes();
+    LoadPalette(sDiplomaPalettes, 0, 64);
+    sDiplomaTilemapPtr = malloc(0x1000);
+    InitDiplomaBg();
+    InitDiplomaWindow();
+    reset_temp_tile_data_buffers();
+    decompress_and_copy_tile_data_to_vram(1, &sDiplomaTiles, 0, 0, 0);
+    while (free_temp_tile_data_buffers_if_possible())
+        ;
+    LZDecompressWram(&sDiplomaTilemap, sDiplomaTilemapPtr);
+    CopyBgTilemapBufferToVram(1);
+    DisplayDiplomaText();
+    BlendPalettes(-1, 16, 0);
+    BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+    EnableInterrupts(1);
+    SetVBlankCallback(VBlankCB);
+    SetMainCallback2(MainCB2);
+    CreateTask(Task_DiplomaFadeIn, 0);
+}
+
+static void MainCB2(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void Task_DiplomaFadeIn(u8 taskId)
+{
+    if (!gPaletteFade.active)
+        gTasks[taskId].func = Task_DiplomaWaitForKeyPress;
+}
+
+static void Task_DiplomaWaitForKeyPress(u8 taskId)
+{
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+    {
+        BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+        gTasks[taskId].func = Task_DiplomaFadeOut;
+    }
+}
+
+static void Task_DiplomaFadeOut(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        Free(sDiplomaTilemapPtr);
+        FreeAllWindowBuffers();
+        DestroyTask(taskId);
+        SetMainCallback2(sub_80861E8);
+    }
+}
+
+static void DisplayDiplomaText(void)
+{
+    if (sub_80C0944())
+    {
+        SetGpuReg(REG_OFFSET_BG1HOFS, DISPCNT_BG0_ON);
+        StringCopy(gStringVar1, gText_DexNational);
+    }
+    else
+    {
+        SetGpuReg(REG_OFFSET_BG1HOFS, DISPCNT_MODE_0);
+        StringCopy(gStringVar1, gText_DexHoenn);
+    }
+    StringExpandPlaceholders(gStringVar4, gText_PokedexDiploma);
+    PrintDiplomaText(gStringVar4, 0, 1);
+    PutWindowTilemap(0);
+    CopyWindowToVram(0, 3);
+}
+
+static const struct BgTemplate sDiplomaBgTemplates[2] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 1,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0,
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 6,
+        .screenSize = 1,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0,
+    },
+};
+
+static void InitDiplomaBg(void)
+{
+    ResetBgsAndClearDma3BusyFlags(0);
+    InitBgsFromTemplates(0, sDiplomaBgTemplates, 2);
+    SetBgTilemapBuffer(1, sDiplomaTilemapPtr);
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+    ShowBg(0);
+    ShowBg(1);
+    SetGpuReg(REG_OFFSET_BLDCNT, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BLDALPHA, DISPCNT_MODE_0);
+    SetGpuReg(REG_OFFSET_BLDY, DISPCNT_MODE_0);
+}
+
+static const struct WindowTemplate sDiplomaWinTemplates[2] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 5,
+        .tilemapTop = 2,
+        .width = 20,
+        .height = 16,
+        .paletteNum = 15,
+        .baseBlock = 1,
+    },
+    DUMMY_WIN_TEMPLATE,
+};
+
+static void InitDiplomaWindow(void)
+{
+    InitWindows(sDiplomaWinTemplates);
+    DeactivateAllTextPrinters();
+    LoadPalette(gUnknown_0860F074, 0xF0, 0x20);
+    FillWindowPixelBuffer(0, 0);
+    PutWindowTilemap(0);
+}
+
+static void PrintDiplomaText(u8 *text, u8 var1, u8 var2)
+{
+    struct TextColor color =
+    {
+        .fgColor = 0,
+        .bgColor = 2,
+        .shadowColor = 3,
+    };
+
+    AddTextPrinterParametrized2(0, 1, var1, var2, 0, 0, &color, -1, text);
+}

src/dma3_manager.c

@@ -1,12 +1,23 @@
 #include "global.h"
 #include "dma3.h"
 
+IWRAM_DATA struct {
+    /* 0x00 */ const u8 *src;
+    /* 0x04 */ u8 *dest;
+    /* 0x08 */ u16 size;
+    /* 0x0A */ u16 mode;
+    /* 0x0C */ u32 value;
+} gDma3Requests[128];
+
+static bool8 gDma3ManagerLocked;
+static u8 gDma3RequestCursor;
+
 void ClearDma3Requests(void)
 {
     int i;
 
     gDma3ManagerLocked = TRUE;
-    gDma3RequestCursor = FALSE;
+    gDma3RequestCursor = 0;
 
     for(i = 0; i < (u8)ARRAY_COUNT(gDma3Requests); i++)
     {
@@ -22,7 +33,6 @@ void ClearDma3Requests(void)
 void ProcessDma3Requests(void)
 {
     // NOTE: the fillerA member of the DMA struct is actually u32 value;
-    // NOTE: gUnknown_0300001C is just a pointer inside the gDma3Requests structure, not a true symbol; feel free to remove
     u16 total_size;
 
     if (gDma3ManagerLocked)
@@ -331,7 +341,7 @@ _08000DB2:\n\
     mov r5, r12\n\
     ldrb r0, [r5]\n\
     lsls r0, 4\n\
-    ldr r3, =gUnknown_0300001C\n\
+    ldr r3, =gDma3Requests + 0x0C\n\
     adds r0, r3\n\
     ldr r0, [r0]\n\
     strh r0, [r1]\n\
@@ -347,7 +357,7 @@ _08000DB2:\n\
     bhi _08000DB2\n\
     ldrb r0, [r5]\n\
     lsls r0, 4\n\
-    ldr r5, =gUnknown_0300001C\n\
+    ldr r5, =gDma3Requests + 0x0C\n\
     adds r0, r5\n\
     ldr r0, [r0]\n\
     strh r0, [r1]\n\

src/easy_chat.c

@@ -3,7 +3,7 @@
 #include "global.h"
 #include "songs.h"
 #include "sound.h"
-#include "rom4.h"
+#include "overworld.h"
 #include "task.h"
 #include "main.h"
 #include "window.h"

src/egg_hatch.c

@@ -59,13 +59,13 @@ extern u8* GetMonNick(struct Pokemon* mon, u8* dst);
 extern u8* GetBoxMonNick(struct BoxPokemon* boxMon, u8* dst);
 extern u8 sav1_map_get_name(void);
 extern s8 sub_8198C58(void);
-extern void sub_81DB5E8(u8* str1, u8* str2, u8);
+extern void TVShowConvertInternationalString(u8* str1, u8* str2, u8);
 extern void sub_806A068(u16, u8);
 extern void fade_screen(u8, u8);
 extern void overworld_free_bg_tilemaps(void);
 extern void sub_80AF168(void);
-extern void init_uns_table_pokemon_copy(void);
-extern void sub_805F094(void);
+extern void AllocateMonSpritesGfx(void);
+extern void FreeMonSpritesGfx(void);
 extern void remove_some_task(void);
 extern void reset_temp_tile_data_buffers(void);
 extern void c2_exit_to_overworld_2_switch(void);
@@ -404,8 +404,8 @@ static bool8 sub_807158C(struct DaycareData* daycare, u8 daycareId)
             || StringCompareWithoutExtCtrlCodes(gSaveBlock2Ptr->playerName, daycareMon->OT_name) != 0))
     {
         StringCopy(gStringVar1, nick);
-        sub_81DB5E8(gStringVar2, daycareMon->OT_name, daycareMon->language_maybe);
-        sub_81DB5E8(gStringVar3, daycareMon->monName, daycareMon->unknown);
+        TVShowConvertInternationalString(gStringVar2, daycareMon->OT_name, daycareMon->language_maybe);
+        TVShowConvertInternationalString(gStringVar3, daycareMon->monName, daycareMon->unknown);
         return TRUE;
     }
     return FALSE;
@@ -439,7 +439,7 @@ static u8 EggHatchCreateMonSprite(u8 a0, u8 switchID, u8 pokeID, u16* speciesLoc
             u16 species = GetMonData(mon, MON_DATA_SPECIES);
             u32 pid = GetMonData(mon, MON_DATA_PERSONALITY);
             HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
-                                                      gBattleSpritesGfx->sprites[(a0 * 2) + 1],
+                                                      gMonSpritesGfxPtr->sprites[(a0 * 2) + 1],
                                                       species, pid);
             LoadCompressedObjectPalette(sub_806E794(mon));
             *speciesLoc = species;
@@ -462,7 +462,7 @@ static void VBlankCB_EggHatch(void)
     TransferPlttBuffer();
 }
 
-static void EggHatch(void)
+void EggHatch(void)
 {
     ScriptContext2_Enable();
     CreateTask(Task_EggHatch, 10);
@@ -488,7 +488,7 @@ static void CB2_EggHatch_0(void)
         SetGpuReg(REG_OFFSET_DISPCNT, 0);
 
         sEggHatchData = Alloc(sizeof(struct EggHatchData));
-        init_uns_table_pokemon_copy();
+        AllocateMonSpritesGfx();
         sEggHatchData->eggPartyID = gSpecialVar_0x8004;
         sEggHatchData->eggShardVelocityID = 0;
 
@@ -570,7 +570,7 @@ static void CB2_EggHatch_0(void)
 static void EggHatchSetMonNickname(void)
 {
     SetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_NICKNAME, gStringVar3);
-    sub_805F094();
+    FreeMonSpritesGfx();
     Free(sEggHatchData);
     SetMainCallback2(c2_exit_to_overworld_2_switch);
 }
@@ -691,7 +691,7 @@ static void CB2_EggHatch_1(void)
     case 12:
         if (!gPaletteFade.active)
         {
-            sub_805F094();
+            FreeMonSpritesGfx();
             RemoveWindow(sEggHatchData->windowId);
             UnsetBgTilemapBuffer(0);
             UnsetBgTilemapBuffer(1);

src/event_data.c

@@ -40,11 +40,11 @@ void ClearTempFieldEventData(void)
 {
     memset(gSaveBlock1Ptr->flags, 0, TEMP_FLAGS_SIZE);
     memset(gSaveBlock1Ptr->vars, 0, TEMP_VARS_SIZE);
-    FlagReset(SYS_ENC_UP_ITEM);
-    FlagReset(SYS_ENC_DOWN_ITEM);
-    FlagReset(SYS_USE_STRENGTH);
-    FlagReset(SYS_CTRL_OBJ_DELETE);
-    FlagReset(SYS_UNKNOWN_880);
+    FlagClear(SYS_ENC_UP_ITEM);
+    FlagClear(SYS_ENC_DOWN_ITEM);
+    FlagClear(SYS_USE_STRENGTH);
+    FlagClear(SYS_CTRL_OBJ_DELETE);
+    FlagClear(SYS_UNKNOWN_880);
 }
 
 // probably had different flag splits at one point.
@@ -58,7 +58,7 @@ void DisableNationalPokedex(void)
     u16 *nationalDexVar = GetVarPointer(VAR_NATIONAL_DEX);
     gSaveBlock2Ptr->pokedex.nationalMagic = 0;
     *nationalDexVar = 0;
-    FlagReset(SYS_NATIONAL_DEX);
+    FlagClear(SYS_NATIONAL_DEX);
 }
 
 void EnableNationalPokedex(void)
@@ -82,7 +82,7 @@ bool32 IsNationalPokedexEnabled(void)
 
 void DisableMysteryEvent(void)
 {
-    FlagReset(SYS_MYSTERY_EVENT_ENABLE);
+    FlagClear(SYS_MYSTERY_EVENT_ENABLE);
 }
 
 void EnableMysteryEvent(void)
@@ -97,7 +97,7 @@ bool32 IsMysteryEventEnabled(void)
 
 void DisableMysteryGift(void)
 {
-    FlagReset(SYS_MYSTERY_GIFT_ENABLE);
+    FlagClear(SYS_MYSTERY_GIFT_ENABLE);
 }
 
 void EnableMysteryGift(void)
@@ -112,22 +112,22 @@ bool32 IsMysteryGiftEnabled(void)
 
 void sub_809D4D8(void)
 {
-    FlagReset(0x1E4);
-    FlagReset(0x1E5);
-    FlagReset(0x1E6);
-    FlagReset(0x1E7);
-    FlagReset(0x1E8);
-    FlagReset(0x1E9);
-    FlagReset(0x1EA);
-    FlagReset(0x1EB);
-    FlagReset(0x1EC);
-    FlagReset(0x1ED);
-    FlagReset(0x1EE);
-    FlagReset(0x1EF);
-    FlagReset(0x1F0);
-    FlagReset(0x1F1);
-    FlagReset(0x1F2);
-    FlagReset(0x1F3);
+    FlagClear(0x1E4);
+    FlagClear(0x1E5);
+    FlagClear(0x1E6);
+    FlagClear(0x1E7);
+    FlagClear(0x1E8);
+    FlagClear(0x1E9);
+    FlagClear(0x1EA);
+    FlagClear(0x1EB);
+    FlagClear(0x1EC);
+    FlagClear(0x1ED);
+    FlagClear(0x1EE);
+    FlagClear(0x1EF);
+    FlagClear(0x1F0);
+    FlagClear(0x1F1);
+    FlagClear(0x1F2);
+    FlagClear(0x1F3);
 }
 
 void sub_809D570(void)
@@ -145,7 +145,7 @@ void sub_809D570(void)
 void DisableResetRTC(void)
 {
     VarSet(VAR_RESET_RTC_ENABLE, 0);
-    FlagReset(SYS_RESET_RTC_ENABLE);
+    FlagClear(SYS_RESET_RTC_ENABLE);
 }
 
 void EnableResetRTC(void)
@@ -214,7 +214,7 @@ u8 FlagSet(u16 id)
     return 0;
 }
 
-u8 FlagReset(u16 id)
+u8 FlagClear(u16 id)
 {
     u8 *ptr = GetFlagPointer(id);
     if (ptr)

src/field_camera.c

@@ -0,0 +1,28 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+struct FieldCameraUnknownStruct
+{
+    u8 unk0;
+    u8 unk1;
+    u8 unk2;
+    u8 unk3;
+    bool8 unk4;
+};
+
+// Static RAM declarations
+
+IWRAM_DATA struct FieldCameraUnknownStruct gUnknown_03000E20;
+IWRAM_DATA s16 gUnknown_03000E28;
+IWRAM_DATA s16 gUnknown_03000E2A;
+IWRAM_DATA u8 gUnknown_03000E2C;
+IWRAM_DATA void (*gUnknown_03000E30)(void);
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/field_effect.c

@@ -0,0 +1,15 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u8 gUnknown_03000F58[32];
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/field_map_obj.c

@@ -3,7 +3,7 @@
 #include "global.h"
 #include "malloc.h"
 #include "sprite.h"
-#include "rom4.h"
+#include "overworld.h"
 #include "rng.h"
 #include "event_scripts.h"
 #include "berry.h"
@@ -2386,10 +2386,10 @@ bool8 do_berry_tree_growth_sparkle_1 (struct MapObject *mapObject, struct Sprite
     {
         if (!(sprite->data7 & 0x0004) && sprite->animNum == 4)
         {
-            gFieldEffectSpawnParams[0] = mapObject->coords2.x;
-            gFieldEffectSpawnParams[1] = mapObject->coords2.y;
-            gFieldEffectSpawnParams[2] = sprite->subpriority - 1;
-            gFieldEffectSpawnParams[3] = sprite->oam.priority;
+            gFieldEffectArguments[0] = mapObject->coords2.x;
+            gFieldEffectArguments[1] = mapObject->coords2.y;
+            gFieldEffectArguments[2] = sprite->subpriority - 1;
+            gFieldEffectArguments[3] = sprite->oam.priority;
             FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE);
             sprite->animNum = berryStage;
         }
@@ -2425,10 +2425,10 @@ bool8 do_berry_tree_growth_sparkle_2 (struct MapObject *mapObject, struct Sprite
     sprite->data1 = 3;
     sprite->data2 = 0;
     sprite->data7 |= 0x0002;
-    gFieldEffectSpawnParams[0] = mapObject->coords2.x;
-    gFieldEffectSpawnParams[1] = mapObject->coords2.y;
-    gFieldEffectSpawnParams[2] = sprite->subpriority - 1;
-    gFieldEffectSpawnParams[3] = sprite->oam.priority;
+    gFieldEffectArguments[0] = mapObject->coords2.x;
+    gFieldEffectArguments[1] = mapObject->coords2.y;
+    gFieldEffectArguments[2] = sprite->subpriority - 1;
+    gFieldEffectArguments[3] = sprite->oam.priority;
     FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE);
     return TRUE;
 }
@@ -3413,7 +3413,7 @@ bool8 mss_08062EA4(struct MapObject *mapObject, struct Sprite *sprite)
     {
         return FALSE;
     }
-    return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), sub_8088E64);
+    return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), MetatileBehavior_IsPokeGrass);
 }
 
 bool8 sub_80925AC(struct MapObject *, struct Sprite *);
@@ -3425,7 +3425,7 @@ void FieldObjectCB_TreeDisguise(struct Sprite *sprite)
     mapObject = &gMapObjects[sprite->data0];
     if (mapObject->mapobj_unk_21 == 0 || (mapObject->mapobj_unk_21 == 1 && !sprite->data7))
     {
-        FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]);
+        FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
         mapObject->mapobj_unk_1A = FieldEffectStart(FLDEFF_TREE_DISGUISE);
         mapObject->mapobj_unk_21 = 1;
         sprite->data7 ++;
@@ -3446,7 +3446,7 @@ void FieldObjectCB_MountainDisguise(struct Sprite *sprite)
     mapObject = &gMapObjects[sprite->data0];
     if (mapObject->mapobj_unk_21 == 0 || (mapObject->mapobj_unk_21 == 1 && !sprite->data7))
     {
-        FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]);
+        FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
         mapObject->mapobj_unk_1A = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE);
         mapObject->mapobj_unk_21 = 1;
         sprite->data7 ++;
@@ -4693,7 +4693,7 @@ bool8 sub_80954CC(struct MapObject *mapObject, struct Sprite *sprite)
 
 bool8 do_exclamation_mark_bubble_1(struct MapObject *mapObject, struct Sprite *sprite)
 {
-    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]);
+    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
     FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_1);
     sprite->data2 = 1;
     return TRUE;
@@ -4701,7 +4701,7 @@ bool8 do_exclamation_mark_bubble_1(struct MapObject *mapObject, struct Sprite *s
 
 bool8 do_exclamation_mark_bubble_2(struct MapObject *mapObject, struct Sprite *sprite)
 {
-    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]);
+    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
     FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_2);
     sprite->data2 = 1;
     return TRUE;
@@ -4709,7 +4709,7 @@ bool8 do_exclamation_mark_bubble_2(struct MapObject *mapObject, struct Sprite *s
 
 bool8 do_heart_bubble(struct MapObject *mapObject, struct Sprite *sprite)
 {
-    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]);
+    FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
     FieldEffectStart(FLDEFF_HEART_ICON);
     sprite->data2 = 1;
     return TRUE;

src/field_screen.c

@@ -0,0 +1,15 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+IWRAM_DATA u8 *gUnknown_03000F50;
+IWRAM_DATA u32 filler_03000f54;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/field_special_scene.c

@@ -0,0 +1,363 @@
+#include "global.h"
+#include "task.h"
+#include "sprite.h"
+#include "field_map_obj.h"
+#include "songs.h"
+#include "sound.h"
+#include "palette.h"
+#include "script.h"
+#include "vars.h"
+#include "event_data.h"
+#include "main.h"
+
+#define SECONDS(value) ((signed) (60.0 * value + 0.5))
+
+extern u8 GetSSTidalLocation(s8 *, s8 *, s16 *, s16 *); // should be in field_specials.h
+extern void Overworld_SetWarpDestination(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y);
+extern bool8 ScriptMovement_IsObjectMovementFinished(u8, u8, u8);
+extern bool32 CountSSTidalStep(u16);
+extern bool8 ScriptMovement_StartObjectMovementScript(u8, u8, u8, u8 *);
+extern void copy_saved_warp2_bank_and_enter_x_to_warp1(u8 unused);
+extern void sp13E_warp_to_last_warp(void);
+extern void saved_warp2_set(int unused, s8 mapGroup, s8 mapNum, s8 warpId);
+extern void sub_80AF8B8(void);
+
+// porthole states
+enum
+{
+    INIT_PORTHOLE,
+    IDLE_CHECK,
+    EXECUTE_MOVEMENT,
+    EXIT_PORTHOLE,
+};
+
+extern void SetCameraPanning(s16 x, s16 y);
+extern void SetCameraPanningCallback(void ( *callback)());
+extern void InstallCameraPanAheadCallback();
+extern void pal_fill_black(void);
+extern void MapGridSetMetatileIdAt(s32 x, s32 y, u16 metatileId);
+extern void DrawWholeMapView();
+
+extern s8 gTruckCamera_HorizontalTable[];
+
+extern u8 gUnknown_0858E8AB[];
+extern u8 gUnknown_0858E8AD[];
+
+void Task_Truck3(u8);
+
+s16 GetTruckCameraBobbingY(int a1)
+{
+    if (!(a1 % 120))
+        return -1;
+    else if ((a1 % 10) <= 4)
+        return 1;
+
+    return 0;
+}
+
+s16 GetTruckBoxMovement(int a1) // for the box movement?
+{
+    if (!((a1 + 120) % 180))
+        return -1;
+
+    return 0;
+}
+
+// smh STILL BROKEN IN EMERALD
+void Task_Truck1(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 cameraYpan;
+    s16 box1 = 0;
+    s16 box2 = 0;
+    s16 box3 = 0;
+    u8 mapNum, mapGroup;
+    register s16 zero asm("r4");
+
+    box1 = GetTruckBoxMovement(data[0] + 30) * 4; // top box.
+    sub_808E82C(1, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 3, box1 + 3);
+    box2 = GetTruckBoxMovement(data[0]) * 2; // bottom left box.
+    sub_808E82C(2, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 0, box2 - 3);
+    box3 = GetTruckBoxMovement(data[0]) * 4; // bottom right box.
+    mapNum = gSaveBlock1Ptr->location.mapNum;
+    mapGroup = gSaveBlock1Ptr->location.mapGroup;
+    zero = 0;
+    sub_808E82C(3, mapNum, mapGroup, -3, box3);
+
+    if (++data[0] == SECONDS(500)) // this will never run
+        data[0] = zero; // reset the timer if it gets stuck.
+
+    cameraYpan = GetTruckCameraBobbingY(data[0]);
+    SetCameraPanning(0, cameraYpan);
+}
+
+void Task_Truck2(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    s16 cameraYpan;
+    s16 cameraXpan;
+    s16 box1;
+    s16 box2;
+    s16 box3;
+
+    data[0]++;
+    data[2]++;
+
+    if (data[0] > 5)
+    {
+        data[0] = 0;
+        data[1]++;
+    }
+    if ((u16)data[1] == 19)
+    {
+        DestroyTask(taskId);
+    }
+    else
+    {
+        if (gTruckCamera_HorizontalTable[data[1]] == 2)
+            gTasks[taskId].func = Task_Truck3;
+
+        cameraXpan = gTruckCamera_HorizontalTable[data[1]];
+        cameraYpan = GetTruckCameraBobbingY(data[2]);
+        SetCameraPanning(cameraXpan, cameraYpan);
+        box1 = GetTruckBoxMovement(data[2] + 30) * 4;
+        sub_808E82C(1, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 3 - cameraXpan, box1 + 3);
+        box2 = GetTruckBoxMovement(data[2]) * 2;
+        sub_808E82C(2, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, -cameraXpan, box2 - 3);
+        box3 = GetTruckBoxMovement(data[2]) * 4;
+        sub_808E82C(3, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, -3 - cameraXpan, box3);
+    }
+}
+
+void Task_Truck3(u8 taskId)
+{
+   s16 *data = gTasks[taskId].data;
+   s16 cameraXpan;
+   s16 cameraYpan;
+
+   data[0]++;
+
+   if (data[0] > 5)
+   {
+       data[0] = 0;
+       data[1]++;
+   }
+
+   if ((u16)data[1] == 19)
+   {
+       DestroyTask(taskId);
+   }
+   else
+   {
+       cameraXpan = gTruckCamera_HorizontalTable[data[1]];
+       cameraYpan = 0;
+       SetCameraPanning(cameraXpan, 0);
+       sub_808E82C(1, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 3 - cameraXpan, cameraYpan + 3);
+       sub_808E82C(2, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, -cameraXpan, cameraYpan - 3);
+       sub_808E82C(3, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, -3 - cameraXpan, cameraYpan);
+   }
+}
+
+void Task_HandleTruckSequence(u8 taskId)
+{
+   s16 *data = gTasks[taskId].data;
+
+    switch (data[0])
+    {
+        /*
+        Each case has a timer which is handled with data[1], incrementing
+        until it reaches the if function's condition, which sets the next task up.
+        */
+    case 0:
+        data[1]++;
+        if (data[1] == SECONDS(1.5))
+        {
+            SetCameraPanningCallback(NULL);
+            data[1] = 0; // reset the timer.
+            data[2] = CreateTask(Task_Truck1, 0xA);
+            data[0] = 1; // run the next case.
+            PlaySE(SE_TRACK_MOVE);
+        }
+        break;
+    case 1:
+        data[1]++;
+        if (data[1] == SECONDS(2.5))
+        {
+            pal_fill_black();
+            data[1] = 0;
+            data[0] = 2;
+        }
+        break;
+    case 2:
+        data[1]++;
+        if (!gPaletteFade.active && data[1] > SECONDS(5))
+        {
+            data[1] = 0;
+            DestroyTask(data[2]);
+            data[3] = CreateTask(Task_Truck2, 0xA);
+            data[0] = 3;
+            PlaySE(SE_TRACK_STOP);
+        }
+        break;
+    case 3:
+        if (!gTasks[data[3]].isActive) // is Truck2 no longer active (is Truck3 active?)
+        {
+            InstallCameraPanAheadCallback();
+            data[1] = 0;
+            data[0] = 4;
+        }
+        break;
+    case 4:
+        data[1]++;
+        if (data[1] == 90)
+        {
+            PlaySE(SE_TRACK_HAIK);
+            data[1] = 0;
+            data[0] = 5;
+        }
+        break;
+    case 5:
+        data[1]++;
+        if (data[1] == 120)
+        {
+            MapGridSetMetatileIdAt(11, 8, 520);
+            MapGridSetMetatileIdAt(11, 9, 528);
+            MapGridSetMetatileIdAt(11, 10, 536);
+            DrawWholeMapView();
+            PlaySE(SE_TRACK_DOOR);
+            DestroyTask(taskId);
+            ScriptContext2_Disable();
+        }
+        break;
+    }
+}
+
+void ExecuteTruckSequence(void)
+{
+    MapGridSetMetatileIdAt(11, 8, 525);
+    MapGridSetMetatileIdAt(11, 9, 533);
+    MapGridSetMetatileIdAt(11, 10, 541);
+    DrawWholeMapView();
+    ScriptContext2_Enable();
+    CpuFastFill(0, gPlttBufferFaded, 0x400);
+    CreateTask(Task_HandleTruckSequence, 0xA);
+}
+
+void EndTruckSequence(u8 taskId)
+{
+    if (!FuncIsActiveTask(Task_HandleTruckSequence))
+    {
+        sub_808E82C(1, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 3, 3);
+        sub_808E82C(2, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, 0, -3);
+        sub_808E82C(3, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, -3, 0);
+    }
+}
+
+bool8 sub_80FB59C(void)
+{
+    s8 mapGroup, mapNum;
+    s16 x, y;
+
+    if (GetSSTidalLocation(&mapGroup, &mapNum, &x, &y))
+    {
+        return FALSE;
+    }
+    else
+    {
+        Overworld_SetWarpDestination(mapGroup, mapNum, -1, x, y);
+        return TRUE;
+    }
+}
+
+void Task_HandlePorthole(u8 taskId)
+{
+    s16 *data = gTasks[taskId].data;
+    u16 *var = GetVarPointer(VAR_PORTHOLE);
+    struct WarpData *location = &gSaveBlock1Ptr->location;
+
+    switch (data[0])
+    {
+    case INIT_PORTHOLE: // finish fading before making porthole finish.
+        if (!gPaletteFade.active)
+        {
+            data[1] = 0;
+            data[0] = EXECUTE_MOVEMENT; // execute movement before checking if should be exited. strange?
+        }
+        break;
+    case IDLE_CHECK: // idle and move.
+        if (gMain.newKeys & A_BUTTON)
+            data[1] = 1;
+        if (!ScriptMovement_IsObjectMovementFinished(0xFF, location->mapNum, location->mapGroup))
+            return;
+        if (CountSSTidalStep(1) == TRUE)
+        {
+            if (*var == 2)
+                *var = 9;
+            else
+                *var = 10;
+            data[0] = 3;
+            return;
+        }
+        data[0] = 2;
+    case EXECUTE_MOVEMENT: // execute movement.
+        if (data[1])
+        {
+            data[0] = EXIT_PORTHOLE; // exit porthole.
+            return;
+        }
+        // run this once.
+        if (*var == 2) // which direction?
+        {
+            ScriptMovement_StartObjectMovementScript(0xFF, location->mapNum, location->mapGroup, gUnknown_0858E8AB);
+            data[0] = IDLE_CHECK; // run case 1.
+        }
+        else
+        {
+            ScriptMovement_StartObjectMovementScript(0xFF, location->mapNum, location->mapGroup, gUnknown_0858E8AD);
+            data[0] = IDLE_CHECK; // run case 1.
+        }
+        break;
+    case EXIT_PORTHOLE: // exit porthole.
+        FlagClear(0x4001);
+        FlagClear(0x4000);
+        copy_saved_warp2_bank_and_enter_x_to_warp1(0);
+        sp13E_warp_to_last_warp();
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+void sub_80FB6EC(void)
+{
+    u8 spriteId = AddPseudoFieldObject(0x8C, SpriteCallbackDummy, 112, 80, 0);
+
+    gSprites[spriteId].coordOffsetEnabled = FALSE;
+
+    if (VarGet(0x40B4) == 2)
+    {
+        StartSpriteAnim(&gSprites[spriteId], FieldObjectDirectionToImageAnimId(4));
+    }
+    else
+    {
+        StartSpriteAnim(&gSprites[spriteId], FieldObjectDirectionToImageAnimId(3));
+    }
+}
+
+void sub_80FB768(void)
+{
+    sub_80FB6EC();
+    gMapObjects[gPlayerAvatar.mapObjectId].mapobj_bit_13 = TRUE;
+    pal_fill_black();
+    CreateTask(Task_HandlePorthole, 80);
+    ScriptContext2_Enable();
+}
+
+void sub_80FB7A4(void)
+{
+    FlagSet(SYS_CRUISE_MODE);
+    FlagSet(0x4001);
+    FlagSet(0x4000);
+    saved_warp2_set(0, gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1);
+    sub_80FB59C();
+    sub_80AF8B8();
+}

src/fldeff_cut.c

@@ -0,0 +1,19 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u8 gUnknown_03001100;
+IWRAM_DATA u8 gUnknown_03001101;
+IWRAM_DATA u8 gUnknown_03001102;
+IWRAM_DATA u32 fldeff_cut_unused_03001104;
+IWRAM_DATA u8 gUnknown_03001108[25];
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/international_string_util.c

@@ -0,0 +1,57 @@
+#include "global.h"
+#include "international_string_util.h"
+#include "text.h"
+
+extern s32 convert_pixel_width_to_tile_width(s32 a0); // script menu
+
+s32 GetStringCenterAlignXOffset(s32 fontId, const u8 *str, s32 totalWidth)
+{
+    return GetStringCenterAlignXOffsetWithLetterSpacing(fontId, str, totalWidth, 0);
+}
+
+s32 GetStringRightAlignXOffset(s32 fontId, const u8 *str, s32 totalWidth)
+{
+    return GetStringWidthDifference(fontId, str, totalWidth, 0);
+}
+
+s32 GetStringCenterAlignXOffsetWithLetterSpacing(s32 fontId, const u8 *str, s32 totalWidth, s32 letterSpacing)
+{
+    return GetStringWidthDifference(fontId, str, totalWidth, letterSpacing) / 2;
+}
+
+s32 GetStringWidthDifference(s32 fontId, const u8 *str, s32 totalWidth, s32 letterSpacing)
+{
+    s32 stringWidth = GetStringWidth(fontId, str, letterSpacing);
+    if (totalWidth > stringWidth)
+        return totalWidth - stringWidth;
+    else
+        return 0;
+}
+
+s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1)
+{
+    s32 i, var;
+
+    for (var = 0, i = 0; i < arg1; i++)
+    {
+        s32 stringWidth = GetStringWidth(1, str[i].text, 0);
+        if (stringWidth > var)
+            var = stringWidth;
+    }
+
+    return convert_pixel_width_to_tile_width(var);
+}
+
+s32 sub_81DB3D8(const struct MenuAction *str, u8* arg1, s32 arg2)
+{
+    s32 i, var;
+
+    for (var = 0, i = 0; i < arg2; i++)
+    {
+        s32 stringWidth = GetStringWidth(1, str[arg1[i]].text, 0);
+        if (stringWidth > var)
+            var = stringWidth;
+    }
+
+    return convert_pixel_width_to_tile_width(var);
+}

src/librfu_intr.c

@@ -0,0 +1,4 @@
+#include "global.h"
+#include "main.h"
+
+//TODO: decompile asm/librfu_intr.s to here

src/librfu_rfu.c

@@ -0,0 +1,109 @@
+#include "global.h"
+#include "main.h"
+
+#include "librfu.h"
+
+struct RfuUnk1
+{
+    u8 unk_0[0x14];
+    u32 unk_14;
+    u32 unk_18;
+    struct RfuIntrStruct unk_1c;
+};
+
+struct RfuUnk2
+{
+    u8 unk_0[0x68];
+    u32 unk_68;
+    u32 unk_6c;
+    u8 unk_70[0x70];
+};
+
+struct RfuUnk3
+{
+    u32 unk_0;
+    u32 unk_4;
+    u8 unk_8[0xD4];
+    u32 unk_dc;
+};
+
+extern u32 *gUnknown_03007890;
+extern u32 *gUnknown_03007894;
+extern struct RfuUnk3* gUnknown_03007898;
+extern struct RfuUnk2* gUnknown_03007880[4];
+extern struct RfuUnk1* gUnknown_03007870[4];
+extern void* sub_82E53F4;
+extern void rfu_STC_clearAPIVariables(void);
+
+// Nonmatching, only register differences
+/*u16 rfu_initializeAPI(u32 *unk0, u16 unk1, IntrFunc *interrupt, bool8 copyInterruptToRam)
+{
+    u16 i;
+    u16 *v13;
+    u16 *v12;
+    u16 num;
+
+    if (((u32)unk0 & 0xF000000) == 0x2000000 && copyInterruptToRam)
+    {
+        return 2;
+    }
+    
+    if ((u32)unk0 & 3)
+        return 2;
+    
+    // Nintendo pls, just use a ternary for once
+    if (copyInterruptToRam)
+    {
+        // An assert/debug print may have existed before, ie
+        // printf("%s %u < %u", "somefile.c:12345", unk1, num)
+        // to push this into r3?
+        num = 0xe64;
+        if (unk1 < num)
+            return 1;
+    }
+
+    if (copyInterruptToRam == FALSE)
+    {
+        num = 0x504; // same as above, this should be r3 not r0
+        if (unk1 < num)
+            return 1;
+    }
+    gUnknown_03007890 = unk0;
+    gUnknown_03007894 = unk0 + (0xB4 / sizeof(u32));
+    gUnknown_03007898 = (struct RfuUnk3*)(unk0 + (0xDC / sizeof(u32)));
+    gUnknown_03007880[0] = (struct RfuUnk2*)(unk0 + (0x1BC / sizeof(u32)));
+    gUnknown_03007870[0] = (struct RfuUnk1*)(unk0 + (0x37C / sizeof(u32)));
+
+    for (i = 1; i < 4; i++, num)
+    {
+        gUnknown_03007880[i] = (struct RfuUnk2*)&gUnknown_03007880[i-1]->unk_70;
+        gUnknown_03007870[i] = (struct RfuUnk1*)&gUnknown_03007870[i-1]->unk_1c;
+    }
+    
+    gUnknown_03007898->unk_dc = (u32)&gUnknown_03007870[3]->unk_1c;
+    STWI_init_all(&gUnknown_03007870[3]->unk_1c, interrupt, copyInterruptToRam);
+    rfu_STC_clearAPIVariables();
+
+    for (i = 0; i < 4; i++)
+    {
+        gUnknown_03007880[i]->unk_68 = 0;
+        gUnknown_03007880[i]->unk_6c = 0;
+        gUnknown_03007870[i]->unk_14 = 0;
+        gUnknown_03007870[i]->unk_18 = 0;
+    }
+
+    // Not matching, register differences
+    v12 = (u16*)((u32)&sub_82E53F4 & ~1);
+    v13 = (u16*)gUnknown_03007898->unk_8;
+        
+    for (i = 47; i != 0xFFFF; i--)
+    {
+        *v13 = *v12;
+        ++v12;
+        ++v13;
+    }
+        
+    gUnknown_03007898->unk_4 = (u32)(&gUnknown_03007898->unk_8[1]);
+        
+    return 0;
+}*/

src/librfu_stwi.c

@@ -0,0 +1,687 @@
+#include "global.h"
+#include "librfu.h"
+
+extern IntrFunc IntrSIO32(void);
+
+extern void STWI_stop_timer(void);
+
+void STWI_init_Callback_M(void);
+void STWI_init_Callback_S(void);
+void STWI_set_Callback_M(void * callback);
+void STWI_set_Callback_S(void * callback);
+u16 STWI_init(u8 request);
+int STWI_start_Command(void);
+void STWI_intr_timer(void);
+void STWI_set_timer(u8 unk);
+
+int STWI_restart_Command(void);
+int STWI_reset_ClockCounter(void);
+
+void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, bool8 copyInterruptToRam)
+{
+    // If we're copying our interrupt into RAM, DMA it to block1 and use
+    // block2 for our RfuStruct, otherwise block1 holds the RfuStruct.
+    // interrupt usually is a pointer to gIntrTable[1]
+    if (copyInterruptToRam == TRUE)
+    {
+        *interrupt = (IntrFunc)interruptStruct->block1;
+        DmaCopy16(3, &IntrSIO32, interruptStruct->block1, 0x960);
+        gRfuState = (struct RfuStruct*)interruptStruct->block2;
+    }
+    else
+    {
+        *interrupt = (IntrFunc)IntrSIO32;
+        gRfuState = (struct RfuStruct*)interruptStruct->block1;
+    }
+
+    gRfuState->rxPacket = (union RfuPacket*)interruptStruct->rxPacketAlloc;
+    gRfuState->txPacket = (union RfuPacket*)interruptStruct->txPacketAlloc;
+    gRfuState->msMode = 1;
+    gRfuState->unk_0 = 0;
+    gRfuState->txParams = 0;
+    gRfuState->unk_5 = 0;
+    gRfuState->unk_7 = 0;
+    gRfuState->unk_8 = 0;
+    gRfuState->unk_9 = 0;
+    gRfuState->timerState = 0;
+    gRfuState->timerActive = 0;
+    gRfuState->unk_12 = 0;
+    gRfuState->unk_15 = 0;
+    gRfuState->unk_2c = 0;
+
+    REG_RCNT = 0x100; //TODO: mystery bit?
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+    STWI_init_Callback_M();
+    STWI_init_Callback_S();
+
+    IntrEnable(INTR_FLAG_SERIAL);
+}
+
+void STWI_init_timer(IntrFunc *interrupt, int timerSelect)
+{
+    *interrupt = STWI_intr_timer;
+    gRfuState->timerSelect = timerSelect;
+
+    IntrEnable(INTR_FLAG_TIMER0 << gRfuState->timerSelect);
+}
+
+void AgbRFU_SoftReset(void)
+{
+    vu16 *timerL;
+    vu16 *timerH;
+
+    REG_RCNT = 0x8000;
+    REG_RCNT = 0x80A0; // all these bits are undocumented
+    timerL = &REG_TMCNT_L(gRfuState->timerSelect);
+    timerH = &REG_TMCNT_H(gRfuState->timerSelect);
+    *timerH = 0;
+    *timerL = 0;
+    *timerH = 0x83;
+    while (*timerL <= 0x11)
+        REG_RCNT = 0x80A2;
+    *timerH = 3;
+    REG_RCNT = 0x80A0;
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+
+    gRfuState->unk_0 = 0;
+    gRfuState->txParams = 0;
+    gRfuState->unk_5 = 0;
+    gRfuState->activeCommand = 0;
+    gRfuState->unk_7 = 0;
+    gRfuState->unk_8 = 0;
+    gRfuState->unk_9 = 0;
+    gRfuState->timerState = 0;
+    gRfuState->timerActive = 0;
+    gRfuState->unk_12 = 0;
+    gRfuState->msMode = 1;
+    gRfuState->unk_15 = 0;
+    gRfuState->unk_2c = 0;
+}
+
+void STWI_set_MS_mode(u8 mode)
+{
+    gRfuState->msMode = mode;
+}
+
+u16 STWI_read_status(u8 index)
+{
+    switch (index)
+    {
+    case 0:
+        return gRfuState->unk_12;
+    case 1:
+        return gRfuState->msMode;
+    case 2:
+        return gRfuState->unk_0;
+    case 3:
+        return gRfuState->activeCommand;
+    default:
+        return 0xFFFF;
+    }
+}
+
+void STWI_init_Callback_M(void)
+{
+    STWI_set_Callback_M(0);
+}
+
+void STWI_init_Callback_S(void)
+{
+    STWI_set_Callback_S(0);
+}
+
+void STWI_set_Callback_M(void *callback)
+{
+    gRfuState->callbackM = callback;
+}
+
+void STWI_set_Callback_S(void *callback)
+{
+    gRfuState->callbackS = callback;
+}
+
+void STWI_set_Callback_ID(u32 id)
+{
+    gRfuState->callbackID = id;
+}
+
+u16 STWI_poll_CommandEnd(void)
+{
+    while (gRfuState->unk_2c == TRUE)
+        ;
+    return gRfuState->unk_12;
+}
+
+void STWI_send_ResetREQ(void)
+{
+    if (!STWI_init(RFU_RESET))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_LinkStatusREQ(void)
+{
+    if (!STWI_init(RFU_LINK_STATUS))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_VersionStatusREQ(void)
+{
+    if (!STWI_init(RFU_VERSION_STATUS))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SystemStatusREQ(void)
+{
+    if (!STWI_init(RFU_SYSTEM_STATUS))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SlotStatusREQ(void)
+{
+    if (!STWI_init(RFU_SLOT_STATUS))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_ConfigStatusREQ(void)
+{
+    if (!STWI_init(RFU_CONFIG_STATUS))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_GameConfigREQ(u8 * unk1, u8 *data)
+{
+    u8 *packetBytes;
+    int i;
+
+    if (!STWI_init(RFU_GAME_CONFIG))
+    {
+        gRfuState->txParams = 6;
+
+        //TODO: what is unk1
+        packetBytes = gRfuState->txPacket->rfuPacket8.data;
+        packetBytes += sizeof(u32);
+        *(u16*)packetBytes = *(u16*)unk1;
+
+        packetBytes += sizeof(u16);
+        unk1 += sizeof(u16);
+
+        for (i = 0; i < 14; i++)
+        {
+            *packetBytes = *unk1;
+            packetBytes++;
+            unk1++;
+        }
+
+        for (i = 0; i < 8; i++)
+        {
+            *packetBytes = *data;
+            packetBytes++;
+            data++;
+        }
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
+{
+    if (!STWI_init(RFU_SYSTEM_CONFIG))
+    {
+        u8 *packetBytes;
+        
+        gRfuState->txParams = 1;
+
+        packetBytes = gRfuState->txPacket->rfuPacket8.data;
+        packetBytes += sizeof(u32);
+
+        *packetBytes++ = unk3;
+        *packetBytes++ = unk2;
+        *(u16*)packetBytes = unk1;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SC_StartREQ(void)
+{
+    if (!STWI_init(RFU_SC_START))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SC_PollingREQ(void)
+{
+    if (!STWI_init(RFU_SC_POLLING))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SC_EndREQ(void)
+{
+    if (!STWI_init(RFU_SC_END))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SP_StartREQ(void)
+{
+    if (!STWI_init(RFU_SP_START))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SP_PollingREQ(void)
+{
+    if (!STWI_init(RFU_SP_POLLING))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_SP_EndREQ(void)
+{
+    if (!STWI_init(RFU_SP_END))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CP_StartREQ(u16 unk1)
+{
+    if (!STWI_init(RFU_CP_START))
+    {
+        gRfuState->txParams = 1;
+        gRfuState->txPacket->rfuPacket32.data[0] = unk1;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CP_PollingREQ(void)
+{
+    if (!STWI_init(RFU_CP_POLLING))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CP_EndREQ(void)
+{
+    if (!STWI_init(RFU_CP_END))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DataTxREQ(void *in, u8 size)
+{
+    if (!STWI_init(RFU_DATA_TX))
+    {
+        u8 txParams = (size / sizeof(u32));
+        if (size & (sizeof(u32) - 1))
+            txParams += 1;
+            
+        gRfuState->txParams = txParams;
+        CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->txParams * sizeof(u32));
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DataTxAndChangeREQ(void *in, u8 size)
+{
+    if (!STWI_init(RFU_DATA_TX_AND_CHANGE))
+    {
+        u8 txParams = (size / sizeof(u32));
+        if (size & (sizeof(u32) - 1))
+            txParams += 1;
+
+        gRfuState->txParams = txParams;
+        CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->txParams * sizeof(u32));
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DataRxREQ(void)
+{
+    if (!STWI_init(RFU_DATA_RX))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_MS_ChangeREQ(void)
+{
+    if (!STWI_init(RFU_MS_CHANGE))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DataReadyAndChangeREQ(u8 unk)
+{
+    if (!STWI_init(RFU_DATA_READY_AND_CHANGE))
+    {
+        if (!unk)
+        {
+            gRfuState->txParams = 0;
+        }
+        else
+        {
+            u8 *packetBytes;
+
+            gRfuState->txParams = 1;
+
+            packetBytes = gRfuState->txPacket->rfuPacket8.data;
+            packetBytes += sizeof(u32);
+
+            *packetBytes++ = unk;
+            *packetBytes++ = 0;
+            *packetBytes++ = 0;
+            *packetBytes = 0;
+        }
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1)
+{
+    if (!STWI_init(RFU_DISCONNECTED_AND_CHANGE))
+    {
+        u8 *packetBytes;
+
+        gRfuState->txParams = 1;
+
+        packetBytes = gRfuState->txPacket->rfuPacket8.data;
+        packetBytes += sizeof(u32);
+
+        *packetBytes++ = unk0;
+        *packetBytes++ = unk1;
+        *packetBytes++ = 0;
+        *packetBytes = 0;
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_ResumeRetransmitAndChangeREQ(void)
+{
+    if (!STWI_init(RFU_RESUME_RETRANSMIT_AND_CHANGE))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_DisconnectREQ(u8 unk)
+{
+    if (!STWI_init(RFU_DISCONNECT))
+    {
+        gRfuState->txParams = 1;
+        gRfuState->txPacket->rfuPacket32.data[0] = unk;
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_TestModeREQ(u8 unk0, u8 unk1)
+{
+    if (!STWI_init(RFU_TEST_MODE))
+    {
+        gRfuState->txParams = 1;
+        gRfuState->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8);
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2)
+{
+    u32 *packetData;
+    u32 arg1;
+    
+    if (!STWI_init(RFU_CPR_START))
+    {
+        gRfuState->txParams = 2;
+        
+        arg1 = unk1 | (unk0 << 16);
+        packetData = gRfuState->txPacket->rfuPacket32.data;
+        packetData[0] = arg1;
+        packetData[1] = unk2;
+
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CPR_PollingREQ(void)
+{
+    if (!STWI_init(RFU_CPR_POLLING))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_CPR_EndREQ(void)
+{
+    if (!STWI_init(RFU_CPR_END))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_send_StopModeREQ(void)
+{
+    if (!STWI_init(RFU_STOP_MODE))
+    {
+        gRfuState->txParams = 0;
+        STWI_start_Command();
+    }
+}
+
+void STWI_intr_timer(void)
+{
+    switch (gRfuState->timerState)
+    {
+        //TODO: Make an enum for these
+        case 2:
+            gRfuState->timerActive = 1;
+            STWI_set_timer(50);
+            break;
+        case 1:
+        case 4:
+            STWI_stop_timer();
+            STWI_restart_Command();
+            break;
+        case 3:
+            gRfuState->timerActive = 1;
+            STWI_stop_timer();
+            STWI_reset_ClockCounter();
+            if (gRfuState->callbackM)
+                gRfuState->callbackM(255, 0);
+            break;
+    }
+}
+
+void STWI_set_timer(u8 unk)
+{
+    vu16 *timerL;
+    vu16 *timerH;
+
+    timerL = &REG_TMCNT_L(gRfuState->timerSelect);
+    timerH = &REG_TMCNT_H(gRfuState->timerSelect);
+    REG_IME = 0;
+    switch (unk)
+    {
+        case 50:
+            *timerL = 0xFCCB;
+            gRfuState->timerState = 1;
+            break;
+        case 80:
+            *timerL = 0xFAE0;
+            gRfuState->timerState = 2;
+            break;
+        case 100:
+            *timerL = 0xF996;
+            gRfuState->timerState = 3;
+            break;
+        case 130:
+            *timerL = 0xF7AD;
+            gRfuState->timerState = 4;
+            break;
+    }
+    *timerH = TIMER_ENABLE | TIMER_INTR_ENABLE | TIMER_1024CLK;
+    REG_IF = INTR_FLAG_TIMER0 << gRfuState->timerSelect;
+    REG_IME = 1;
+}
+
+void STWI_stop_timer(void)
+{
+    gRfuState->timerState = 0;
+    
+    REG_TMCNT_L(gRfuState->timerSelect) = 0;
+    REG_TMCNT_H(gRfuState->timerSelect) = 0;
+}
+
+u16 STWI_init(u8 request)
+{
+    if (!REG_IME)
+    {
+        gRfuState->unk_12 = 6;
+        if (gRfuState->callbackM)
+            gRfuState->callbackM(request, gRfuState->unk_12);
+        return TRUE;
+    }
+    else if (gRfuState->unk_2c == TRUE)
+    {
+        gRfuState->unk_12 = 2;
+        gRfuState->unk_2c = FALSE;
+        if (gRfuState->callbackM)
+            gRfuState->callbackM(request, gRfuState->unk_12);
+        return TRUE;
+    }
+    else if(!gRfuState->msMode)
+    {
+        gRfuState->unk_12 = 4;
+        if (gRfuState->callbackM)
+            gRfuState->callbackM(request, gRfuState->unk_12, gRfuState);
+        return TRUE;
+    }
+    else
+    {
+        gRfuState->unk_2c = TRUE;
+        gRfuState->activeCommand = request;
+        gRfuState->unk_0 = 0;
+        gRfuState->txParams = 0;
+        gRfuState->unk_5 = 0;
+        gRfuState->unk_7 = 0;
+        gRfuState->unk_8 = 0;
+        gRfuState->unk_9 = 0;
+        gRfuState->timerState = 0;
+        gRfuState->timerActive = 0;
+        gRfuState->unk_12 = 0;
+        gRfuState->unk_15 = 0;
+        
+        REG_RCNT = 0x100;
+        REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+        return FALSE;
+    }
+}
+
+int STWI_start_Command()
+{
+    u16 imeTemp;
+    
+    // Yes, it matters that it's casted to a u32...
+    *(u32*)gRfuState->txPacket->rfuPacket8.data = 0x99660000 | (gRfuState->txParams << 8) | gRfuState->activeCommand;
+    REG_SIODATA32 = gRfuState->txPacket->rfuPacket32.command;
+    
+    gRfuState->unk_0 = 0;
+    gRfuState->unk_5 = 1;
+    
+    imeTemp = REG_IME;
+    REG_IME = 0;
+    REG_IE |= (INTR_FLAG_TIMER0 << gRfuState->timerSelect);
+    REG_IE |= INTR_FLAG_SERIAL;
+    REG_IME = imeTemp;
+    
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_MULTI_BUSY | SIO_115200_BPS;
+    
+    return 0;
+}
+
+int STWI_restart_Command(void)
+{
+    if (gRfuState->unk_15 <= 1)
+    {
+        gRfuState->unk_15++;
+        STWI_start_Command();
+    }
+    else
+    {
+        if (gRfuState->activeCommand == RFU_MS_CHANGE || gRfuState->activeCommand == RFU_DATA_TX_AND_CHANGE || gRfuState->activeCommand == RFU_UNK35 || gRfuState->activeCommand == RFU_RESUME_RETRANSMIT_AND_CHANGE)
+        {
+            gRfuState->unk_12 = 1;
+            gRfuState->unk_2c = 0;
+            
+            if (gRfuState->callbackM)
+                gRfuState->callbackM(gRfuState->activeCommand, gRfuState->unk_12);
+        }
+        else
+        {
+            gRfuState->unk_12 = 1;
+            gRfuState->unk_2c = 0;
+            
+            if (gRfuState->callbackM)
+                gRfuState->callbackM(gRfuState->activeCommand, gRfuState->unk_12);
+            
+            gRfuState->unk_0 = 4; //TODO: what's 4
+        }
+    }
+    
+    return 0;
+}
+
+int STWI_reset_ClockCounter()
+{
+    gRfuState->unk_0 = 5; //TODO: what is 5
+    gRfuState->txParams = 0;
+    gRfuState->unk_5 = 0;
+    REG_SIODATA32 = (1 << 31);
+    REG_SIOCNT = 0;
+    REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+    REG_SIOCNT = (SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS) + 0x7F;
+    
+    return 0;
+}

src/lilycove_lady.c

@@ -4,7 +4,7 @@
 
 #include "global.h"
 #include "main.h"
-#include "rom4.h"
+#include "overworld.h"
 #include "rom6.h"
 #include "event_data.h"
 #include "script.h"

src/link.c

@@ -0,0 +1,56 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+struct BlockTransfer
+{
+    u16 pos;
+    u16 size;
+    void *src;
+    bool8 active;
+    u8 multiplayerId;
+};
+
+struct LinkTestBGInfo
+{
+    u32 screenBaseBlock;
+    u32 paletteNum;
+    u32 dummy_8;
+    u32 dummy_C;
+};
+
+// Static RAM declarations
+
+IWRAM_DATA struct BlockTransfer gUnknown_03000D10;
+IWRAM_DATA u32 link_c_unused_03000d1c;
+IWRAM_DATA struct BlockTransfer gUnknown_03000D20[4];
+IWRAM_DATA u32 gUnknown_03000D50;
+IWRAM_DATA u32 gUnknown_03000D54;
+IWRAM_DATA u8 gUnknown_03000D58;
+IWRAM_DATA u32 gUnknown_03000D5C;
+IWRAM_DATA u32 gUnknown_03000D60;
+IWRAM_DATA u8 gUnknown_03000D64[4]; // not really, but won't match otherwise
+IWRAM_DATA u8 gUnknown_03000D68[4];
+IWRAM_DATA u8 gUnknown_03000D6C;
+IWRAM_DATA bool8 gUnknown_03000D6D;
+IWRAM_DATA u16 gUnknown_03000D6E;
+IWRAM_DATA u16 gUnknown_03000D70;
+IWRAM_DATA u8 gUnknown_03000D72;
+IWRAM_DATA u8 gUnknown_03000D73;
+IWRAM_DATA u8 gUnknown_03000D74[4]; // not really, but won't match otherwise
+IWRAM_DATA u8 gUnknown_03000D78[8]; // not really, but won't match otherwise
+IWRAM_DATA u8 gUnknown_03000D80[16];
+IWRAM_DATA u16 gUnknown_03000D90[8];
+IWRAM_DATA u32 gUnknown_03000DA0;
+IWRAM_DATA u32 gUnknown_03000DA4;
+IWRAM_DATA void *gUnknown_03000DA8;
+IWRAM_DATA void *gUnknown_03000DAC;
+IWRAM_DATA bool32 gUnknown_03000DB0;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/mail.c

@@ -0,0 +1,577 @@
+
+// Includes
+#include "global.h"
+#include "main.h"
+#include "overworld.h"
+#include "task.h"
+#include "unknown_task.h"
+#include "palette.h"
+#include "menu.h"
+#include "menu_helpers.h"
+#include "text.h"
+#include "text_window.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "strings.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "pokemon_icon.h"
+#include "species.h"
+#include "malloc.h"
+#include "easy_chat.h"
+#include "mail_data.h"
+#include "mail.h"
+
+// Static type declarations
+
+struct UnkMailStruct
+{
+    u32 numEasyChatWords:2;
+    u32 xOffset:6;
+    u32 lineHeight:8;
+};
+
+struct MailLayout
+{
+    u8 numSubStructs;
+    u8 signatureYPos;
+    u8 signatureWidth;
+    u8 wordsXPos;
+    u8 wordsYPos;
+    const struct UnkMailStruct *var8;
+};
+
+struct MailGraphics
+{
+    const u16 *palette;
+    const u8 *tiles;
+    const u8 *tileMap;
+    u16 var0C;
+    u16 var0E;
+    u16 color10;
+    u16 color12;
+};
+
+// Static RAM declarations
+
+static EWRAM_DATA struct
+{
+    /*0x0000*/ u8 strbuf[8][64];
+    /*0x0200*/ u8 playerName[12];
+    /*0x020C*/ MainCallback callback;
+    /*0x0210*/ MainCallback callback2;
+    /*0x0214*/ struct MailStruct *mail;
+    /*0x0218*/ bool8 flag;
+    /*0x0219*/ u8 signatureWidth;
+    /*0x021a*/ u8 mailType;
+    /*0x021b*/ u8 animsActive;
+    /*0x021c*/ u8 monIconSprite;
+    /*0x021d*/ u8 language;
+    /*0x021e*/ bool8 playerIsSender;
+    /*0x0220*/ void (*parserSingle)(u8 *dest, u16 word);
+    /*0x0224*/ void (*parserMultiple)(u8 *dest, const u16 *src, u16 length1, u16 length2);
+    /*0x0228*/ const struct MailLayout *layout;
+    /*0x022c*/ u8 bg1TilemapBuffer[0x1000];
+    /*0x122c*/ u8 bg2TilemapBuffer[0x1000];
+} *gUnknown_0203A134 = NULL;
+
+// Static ROM declarations
+
+void sub_81219F0(void);
+void sub_8121A1C(void);
+void sub_8121B1C(void);
+void sub_8121C50(void);
+void sub_8121C64(void);
+void sub_8121C98(void);
+void sub_8121CC0(void);
+void sub_8121D00(void);
+
+// .rodata
+
+const struct BgTemplate gUnknown_0859F290[] = {
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .priority = 0
+    }, {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 30,
+        .priority = 1
+    }, {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 29,
+        .priority = 2
+    }
+};
+
+const struct WindowTemplate gUnknown_0859F29C[] = {
+    {
+        .priority = 0,
+        .tilemapLeft = 2,
+        .tilemapTop = 3,
+        .width = 26,
+        .height = 15,
+        .paletteNum = 15,
+        .baseBlock = 1
+    },
+    DUMMY_WIN_TEMPLATE
+};
+
+const u8 gUnknown_0859F2AC[] = {
+     0,
+    10,
+    11
+};
+
+const u16 gUnknown_0859F2B0[][2] = {
+    { 0x6ACD, 0x51A5 },
+    { 0x45FC, 0x38D4 }
+};
+
+extern const u16 gUnknown_08DBE818[];
+extern const u16 gUnknown_08DBE838[];
+extern const u16 gUnknown_08DBE858[];
+extern const u16 gUnknown_08DBE878[];
+extern const u16 gUnknown_08DBE898[];
+extern const u16 gUnknown_08DBE8B8[];
+extern const u16 gUnknown_08DBE8D8[];
+extern const u16 gUnknown_08DBE8F8[];
+extern const u16 gUnknown_08DBE918[];
+extern const u16 gUnknown_08DBE938[];
+extern const u16 gUnknown_08DBE958[];
+extern const u16 gUnknown_08DBE978[];
+extern const u8 gUnknown_08DBE998[];
+extern const u8 gUnknown_08DBFBA4[];
+extern const u8 gUnknown_08DBEB38[];
+extern const u8 gUnknown_08DBFC7C[];
+extern const u8 gUnknown_08DBEC74[];
+extern const u8 gUnknown_08DBFD5C[];
+extern const u8 gUnknown_08DBEE84[];
+extern const u8 gUnknown_08DBFE68[];
+extern const u8 gUnknown_08DBEF5C[];
+extern const u8 gUnknown_08DBFF44[];
+extern const u8 gUnknown_08DBF154[];
+extern const u8 gUnknown_08DC0034[];
+extern const u8 gUnknown_08DBF2D4[];
+extern const u8 gUnknown_08DC0114[];
+extern const u8 gUnknown_08DBF37C[];
+extern const u8 gUnknown_08DC01F4[];
+extern const u8 gUnknown_08DBF50C[];
+extern const u8 gUnknown_08DC0300[];
+extern const u8 gUnknown_08DBF64C[];
+extern const u8 gUnknown_08DC03F0[];
+extern const u8 gUnknown_08DBF7B4[];
+extern const u8 gUnknown_08DC04E8[];
+extern const u8 gUnknown_08DBF904[];
+extern const u8 gUnknown_08DC0600[];
+
+const struct MailGraphics gUnknown_0859F2B8[] = {
+    {
+        gUnknown_08DBE818, gUnknown_08DBE998, gUnknown_08DBFBA4, 0x02c0, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE838, gUnknown_08DBEB38, gUnknown_08DBFC7C, 0x02e0, 0x0000, 0x7fff, 0x4631
+    }, {
+        gUnknown_08DBE858, gUnknown_08DBEC74, gUnknown_08DBFD5C, 0x0400, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE878, gUnknown_08DBEE84, gUnknown_08DBFE68, 0x01e0, 0x0000, 0x7fff, 0x4631
+    }, {
+        gUnknown_08DBE898, gUnknown_08DBEF5C, gUnknown_08DBFF44, 0x02e0, 0x0000, 0x7fff, 0x4631
+    }, {
+        gUnknown_08DBE8B8, gUnknown_08DBF154, gUnknown_08DC0034, 0x0300, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE8D8, gUnknown_08DBF2D4, gUnknown_08DC0114, 0x0140, 0x0000, 0x7fff, 0x4631
+    }, {
+        gUnknown_08DBE8F8, gUnknown_08DBF37C, gUnknown_08DC01F4, 0x0300, 0x0000, 0x7fff, 0x4631
+    }, {
+        gUnknown_08DBE918, gUnknown_08DBF50C, gUnknown_08DC0300, 0x0220, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE938, gUnknown_08DBF64C, gUnknown_08DC03F0, 0x0340, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE958, gUnknown_08DBF7B4, gUnknown_08DC04E8, 0x02a0, 0x0000, 0x294a, 0x6739
+    }, {
+        gUnknown_08DBE978, gUnknown_08DBF904, gUnknown_08DC0600, 0x0520, 0x0000, 0x294a, 0x6739
+    }
+};
+
+const struct UnkMailStruct Unknown_0859F3A8[] = {
+    { .numEasyChatWords = 3, .lineHeight = 16 },
+    { .numEasyChatWords = 3, .lineHeight = 16 },
+    { .numEasyChatWords = 3, .lineHeight = 16 }
+};
+
+const struct MailLayout gUnknown_0859F3B4[] = {
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x08, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+    { 0x03, 0x00, 0x00, 0x02, 0x00, Unknown_0859F3A8 }
+};
+
+const struct UnkMailStruct Unknown_0859F444[] = {
+    { .numEasyChatWords = 2, .lineHeight = 16 },
+    { .numEasyChatWords = 2, .lineHeight = 16 },
+    { .numEasyChatWords = 2, .lineHeight = 16 },
+    { .numEasyChatWords = 2, .lineHeight = 16 },
+    { .numEasyChatWords = 1, .lineHeight = 16 }
+};
+
+const struct MailLayout gUnknown_0859F458[] = {
+    { 0x05, 0x07, 0x58, 0x0b, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x0a, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x0c, 0x68, 0x05, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x05, 0x60, 0x08, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x0a, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x09, 0x70, 0x05, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x0c, 0x68, 0x09, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x0d, 0x68, 0x0d, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x09, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x09, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x11, 0x68, 0x0f, 0x1e, Unknown_0859F444 },
+    { 0x05, 0x09, 0x60, 0x05, 0x1e, Unknown_0859F444 }
+};
+
+// What the heck are these meant to be? Call them u16 for now.
+
+const u16 Unknown_0859F4E8[] = {
+    0x00, 0x4000, 0x00, 0x00
+};
+
+const u16 Unknown_0859F4F0[] = {
+    0x00, 0x00, -1, 0x00
+};
+
+const u16 Unknown_0859F4F8[] = {
+    0x04, 0x00, -1, 0x00
+};
+
+const u16 Unknown_0859F500[] = {
+    0x00, 0x40, -1, 0x00
+};
+
+const u16 *const gUnknown_0859F508[] = {
+    Unknown_0859F4F0,
+    Unknown_0859F4F8,
+    Unknown_0859F500
+};
+
+// .text
+
+void sub_8121478(struct MailStruct *mail, MainCallback callback, bool8 flag) {
+    u16 buffer[2];
+    u16 species;
+
+    gUnknown_0203A134 = calloc(1, sizeof(*gUnknown_0203A134));
+    gUnknown_0203A134->language = LANGUAGE_ENGLISH;
+    gUnknown_0203A134->playerIsSender = TRUE;
+    gUnknown_0203A134->parserSingle = CopyEasyChatWord;
+    gUnknown_0203A134->parserMultiple = ConvertEasyChatWordsToString;
+    if (mail->itemId >= ITEM_ORANGE_MAIL && mail->itemId <= ITEM_RETRO_MAIL) {
+        gUnknown_0203A134->mailType = mail->itemId - ITEM_ORANGE_MAIL;
+    }
+    else
+    {
+        gUnknown_0203A134->mailType = 0;
+        flag = FALSE;
+    }
+    switch (gUnknown_0203A134->playerIsSender)
+    {
+        case FALSE:
+        default:
+            gUnknown_0203A134->layout = &gUnknown_0859F3B4[gUnknown_0203A134->mailType];
+            break;
+        case TRUE:
+            gUnknown_0203A134->layout = &gUnknown_0859F458[gUnknown_0203A134->mailType];
+            break;
+    }
+    species = sub_80D45E8(mail->species, buffer);
+    if (species >= SPECIES_BULBASAUR && species < NUM_SPECIES)
+    {
+        switch (gUnknown_0203A134->mailType)
+        {
+            default:
+                gUnknown_0203A134->animsActive = 0;
+                break;
+            case ITEM_BEAD_MAIL - ITEM_ORANGE_MAIL:
+                gUnknown_0203A134->animsActive = 1;
+                break;
+            case ITEM_DREAM_MAIL - ITEM_ORANGE_MAIL:
+                gUnknown_0203A134->animsActive = 2;
+                break;
+        }
+    }
+    else
+    {
+        gUnknown_0203A134->animsActive = 0;
+    }
+    gUnknown_0203A134->mail = mail;
+    gUnknown_0203A134->callback = callback;
+    gUnknown_0203A134->flag = flag;
+    SetMainCallback2(sub_81219F0);
+}
+
+bool8 sub_81215EC(void)
+{
+    u16 icon;
+
+    switch (gMain.state)
+    {
+        case 0:
+            SetVBlankCallback(NULL);
+            remove_some_task();
+            SetGpuReg(REG_OFFSET_DISPCNT, 0x0000);
+            break;
+        case 1:
+            CpuFill16(0, (void *)OAM, OAM_SIZE);
+            break;
+        case 2:
+            ResetPaletteFade();
+            break;
+        case 3:
+            ResetTasks();
+            break;
+        case 4:
+            ResetSpriteData();
+            break;
+        case 5:
+            FreeAllSpritePalettes();
+            reset_temp_tile_data_buffers();
+            SetGpuReg(REG_OFFSET_BG0HOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG0VOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG1HOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG1VOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG2VOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG2HOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG3HOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BG3VOFS, 0x0000);
+            SetGpuReg(REG_OFFSET_BLDCNT, 0x0000);
+            SetGpuReg(REG_OFFSET_BLDALPHA, 0x0000);
+            break;
+        case 6:
+            ResetBgsAndClearDma3BusyFlags(0);
+            InitBgsFromTemplates(0, gUnknown_0859F290, 3);
+            SetBgTilemapBuffer(1, gUnknown_0203A134->bg1TilemapBuffer);
+            SetBgTilemapBuffer(2, gUnknown_0203A134->bg2TilemapBuffer);
+            break;
+        case 7:
+            InitWindows(gUnknown_0859F29C);
+            DeactivateAllTextPrinters();
+            break;
+        case 8:
+            decompress_and_copy_tile_data_to_vram(1, gUnknown_0859F2B8[gUnknown_0203A134->mailType].tiles, 0, 0, 0);
+            break;
+        case 9:
+            if (free_temp_tile_data_buffers_if_possible())
+            {
+                return FALSE;
+            }
+            break;
+        case 10:
+            FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+            FillBgTilemapBufferRect_Palette0(2, 1, 0, 0, 30, 20);
+            CopyToBgTilemapBuffer(1, gUnknown_0859F2B8[gUnknown_0203A134->mailType].tileMap, 0, 0);
+            break;
+        case 11:
+            CopyBgTilemapBufferToVram(0);
+            CopyBgTilemapBufferToVram(1);
+            CopyBgTilemapBufferToVram(2);
+            break;
+        case 12:
+            LoadPalette(sub_8098C64(), 240, 32);
+            gPlttBufferUnfaded[250] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color10;
+            gPlttBufferFaded[250] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color10;
+            gPlttBufferUnfaded[251] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color12;
+            gPlttBufferFaded[251] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color12;
+            LoadPalette(gUnknown_0859F2B8[gUnknown_0203A134->mailType].palette, 0, 32);
+            gPlttBufferUnfaded[10] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][0];
+            gPlttBufferFaded[10] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][0];
+            gPlttBufferUnfaded[11] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][1];
+            gPlttBufferFaded[11] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][1];
+            break;
+        case 13:
+            if (gUnknown_0203A134->flag)
+            {
+                sub_8121A1C();
+            }
+            break;
+        case 14:
+            if (gUnknown_0203A134->flag)
+            {
+                sub_8121B1C();
+                RunTextPrinters();
+            }
+            break;
+        case 15:
+            if (sub_8087598() == TRUE)
+            {
+                return FALSE;
+            }
+            break;
+        case 16:
+            SetVBlankCallback(sub_8121C50);
+            gPaletteFade.bufferTransferDisabled = TRUE;
+            break;
+        case 17:
+            icon = sub_80D2E84(gUnknown_0203A134->mail->species);
+            switch (gUnknown_0203A134->animsActive)
+            {
+                case 1:
+                    sub_80D2F68(icon);
+                    gUnknown_0203A134->monIconSprite = sub_80D2D78(icon, SpriteCallbackDummy, 0x60, 0x80, 0, 0);
+                    break;
+                case 2:
+                    sub_80D2F68(icon);
+                    gUnknown_0203A134->monIconSprite = sub_80D2D78(icon, SpriteCallbackDummy, 0x28, 0x80, 0, 0);
+                    break;
+            }
+            break;
+        case 18:
+            SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+            ShowBg(0);
+            ShowBg(1);
+            ShowBg(2);
+            BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+            gPaletteFade.bufferTransferDisabled = FALSE;
+            gUnknown_0203A134->callback2 = sub_8121C98;
+            return TRUE;
+        default:
+            return FALSE;
+    }
+    gMain.state ++;
+    return FALSE;
+}
+
+void sub_81219F0(void)
+{
+    do
+    {
+        if (sub_81215EC() == TRUE)
+        {
+            SetMainCallback2(sub_8121C64);
+            break;
+        }
+    } while (sub_81221AC() != TRUE);
+}
+
+void sub_8121A1C(void)
+{
+    u16 i;
+    u8 total;
+    u8 *ptr;
+
+    total = 0;
+    for (i = 0; i < gUnknown_0203A134->layout->numSubStructs; i ++)
+    {
+        ConvertEasyChatWordsToString(gUnknown_0203A134->strbuf[i], &gUnknown_0203A134->mail->words[total], gUnknown_0203A134->layout->var8[i].numEasyChatWords, 1);
+        total += gUnknown_0203A134->layout->var8[i].numEasyChatWords;
+    }
+    ptr = StringCopy(gUnknown_0203A134->playerName, gUnknown_0203A134->mail->playerName);
+    if (!gUnknown_0203A134->playerIsSender)
+    {
+        StringCopy(ptr, gText_FromSpace);
+        gUnknown_0203A134->signatureWidth = gUnknown_0203A134->layout->signatureWidth - (StringLength(gUnknown_0203A134->playerName) * 8 - 0x60);
+    }
+    else
+    {
+        sub_81DB52C(gUnknown_0203A134->playerName);
+        gUnknown_0203A134->signatureWidth = gUnknown_0203A134->layout->signatureWidth;
+    }
+}
+
+void sub_8121B1C(void)
+{
+    u16 i;
+    u8 strbuf[0x20];
+    u8 y;
+    u8 *bufptr;
+    s32 box_x;
+    s32 box_y;
+
+    y = 0;
+    PutWindowTilemap(0);
+    PutWindowTilemap(1);
+    FillWindowPixelBuffer(0, 0);
+    FillWindowPixelBuffer(1, 0);
+    for (i = 0; i < gUnknown_0203A134->layout->numSubStructs; i ++)
+    {
+        if (gUnknown_0203A134->strbuf[i][0] == EOS || gUnknown_0203A134->strbuf[i][0] == CHAR_SPACE)
+        {
+            continue;
+        }
+        box_print(0, 1, gUnknown_0203A134->layout->var8[i].xOffset + gUnknown_0203A134->layout->wordsYPos, y + gUnknown_0203A134->layout->wordsXPos, gUnknown_0859F2AC, 0, gUnknown_0203A134->strbuf[i]);
+        y += gUnknown_0203A134->layout->var8[i].lineHeight;
+    }
+    bufptr = StringCopy(strbuf, gText_FromSpace);
+    StringCopy(bufptr, gUnknown_0203A134->playerName);
+    box_x = GetStringCenterAlignXOffset(1, strbuf, gUnknown_0203A134->signatureWidth) + 0x68;
+    box_y = gUnknown_0203A134->layout->signatureYPos + 0x58;
+    box_print(0, 1, box_x, box_y, gUnknown_0859F2AC, 0, strbuf);
+    CopyWindowToVram(0, 3);
+    CopyWindowToVram(1, 3);
+}
+
+void sub_8121C50(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void sub_8121C64(void)
+{
+    if (gUnknown_0203A134->animsActive != 0)
+    {
+        AnimateSprites();
+        BuildOamBuffer();
+    }
+    gUnknown_0203A134->callback2();
+}
+
+void sub_8121C98(void)
+{
+    if (!UpdatePaletteFade())
+    {
+        gUnknown_0203A134->callback2 = sub_8121CC0;
+    }
+}
+
+void sub_8121CC0(void)
+{
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+    {
+        BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+        gUnknown_0203A134->callback2 = sub_8121D00;
+    }
+}
+
+void sub_8121D00(void)
+{
+    if (!UpdatePaletteFade())
+    {
+        SetMainCallback2(gUnknown_0203A134->callback);
+        switch (gUnknown_0203A134->animsActive)
+        {
+            case 1:
+            case 2:
+                sub_80D2FF0(sub_80D2E84(gUnknown_0203A134->mail->species));
+                sub_80D2EF8(&gSprites[gUnknown_0203A134->monIconSprite]);
+        }
+        memset(gUnknown_0203A134, 0, sizeof(*gUnknown_0203A134));
+        ResetPaletteFade();
+        UnsetBgTilemapBuffer(0);
+        UnsetBgTilemapBuffer(1);
+        ResetBgsAndClearDma3BusyFlags(0);
+        FreeAllWindowBuffers();
+        free(gUnknown_0203A134);
+        gUnknown_0203A134 = NULL;
+    }
+}

src/main.c

@@ -77,7 +77,7 @@ const IntrFunc gIntrTableTemplate[] =
 
 #define INTR_COUNT ((int)(sizeof(gIntrTableTemplate)/sizeof(IntrFunc)))
 
-extern u16 gUnknown_03000000;
+static u16 gUnknown_03000000;
 
 extern u16 gKeyRepeatStartDelay;
 extern u8 gUnknown_030022B4;

src/main_menu.c

@@ -0,0 +1,15 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u8 gUnknown_03000DD0;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/malloc.c

@@ -2,6 +2,7 @@
 
 static void *sHeapStart;
 static u32 sHeapSize;
+static u32 malloc_c_unused_0300000c; // needed to align dma3_manager.o(.bss)
 
 #define MALLOC_SYSTEM_ID 0xA3A3
 

src/money.c

@@ -1,8 +1,77 @@
 #include "global.h"
 #include "money.h"
+#include "event_data.h"
+#include "string_util.h"
+#include "text.h"
+#include "menu.h"
+#include "window.h"
+#include "sprite.h"
+#include "decompress.h"
+
+extern const u8 gText_PokedollarVar1[];
+
+extern const u8 gMenuMoneyGfx[];
+extern const u8 gMenuMoneyPal[];
 
 #define MAX_MONEY 999999
 
+EWRAM_DATA static u8 sMoneyBoxWindowId = 0;
+EWRAM_DATA static u8 sMoneyLabelSpriteId = 0;
+
+#define MONEY_LABEL_TAG 0x2722
+
+static const struct OamData sOamData_MoneyLabel =
+{
+    .y = 0,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 1,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 2,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const union AnimCmd sSpriteAnim_MoneyLabel[] =
+{
+    ANIMCMD_FRAME(0, 0),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_MoneyLabel[] =
+{
+    sSpriteAnim_MoneyLabel,
+};
+
+static const struct SpriteTemplate sSpriteTemplate_MoneyLabel =
+{
+    .tileTag = MONEY_LABEL_TAG,
+    .paletteTag = MONEY_LABEL_TAG,
+    .oam = &sOamData_MoneyLabel,
+    .anims = sSpriteAnimTable_MoneyLabel,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy
+};
+
+static const struct CompressedSpriteSheet sSpriteSheet_MoneyLabel =
+{
+    .data = gMenuMoneyGfx,
+    .size = 256,
+    .tag = MONEY_LABEL_TAG,
+};
+
+static const struct CompressedSpritePalette sSpritePalette_MoneyLabel =
+{
+    .data = gMenuMoneyPal,
+    .tag = MONEY_LABEL_TAG
+};
+
 u32 GetMoney(u32* moneyPtr)
 {
     return *moneyPtr ^ gSaveBlock2Ptr->encryptionKey;
@@ -41,7 +110,7 @@ void AddMoney(u32* moneyPtr, u32 toAdd)
     SetMoney(moneyPtr, toSet);
 }
 
-void SubtractMoney(u32* moneyPtr, u32 toSub)
+void RemoveMoney(u32* moneyPtr, u32 toSub)
 {
     u32 toSet = GetMoney(moneyPtr);
 
@@ -53,3 +122,79 @@ void SubtractMoney(u32* moneyPtr, u32 toSub)
 
     SetMoney(moneyPtr, toSet);
 }
+
+bool8 IsEnoughForCostInVar0x8005(void)
+{
+    return IsEnoughMoney(&gSaveBlock1Ptr->money, gSpecialVar_0x8005);
+}
+
+void SubtractMoneyFromVar0x8005(void)
+{
+    RemoveMoney(&gSaveBlock1Ptr->money, gSpecialVar_0x8005);
+}
+
+void PrintMoneyAmountInMoneyBox(u8 windowId, int amount, u8 speed)
+{
+    PrintMoneyAmount(windowId, 0x26, 1, amount, speed);
+}
+
+void PrintMoneyAmount(u8 windowId, u8 x, u8 y, int amount, u8 speed)
+{
+    u8 *txtPtr;
+    s32 strLength;
+
+    ConvertIntToDecimalStringN(gStringVar1, amount, STR_CONV_MODE_LEFT_ALIGN, 6);
+
+    strLength = 6 - StringLength(gStringVar1);
+    txtPtr = gStringVar4;
+
+    while (strLength-- > 0)
+        *(txtPtr++) = 0x77;
+
+    StringExpandPlaceholders(txtPtr, gText_PokedollarVar1);
+    PrintTextOnWindow(windowId, 1, gStringVar4, x, y, speed, NULL);
+}
+
+void PrintMoneyAmountInMoneyBoxWithBorder(u8 windowId, u16 tileStart, u8 pallete, int amount)
+{
+    SetWindowBorderStyle(windowId, FALSE, tileStart, pallete);
+    PrintMoneyAmountInMoneyBox(windowId, amount, 0);
+}
+
+void ChangeAmountInMoneyBox(int amount)
+{
+    PrintMoneyAmountInMoneyBox(sMoneyBoxWindowId, amount, 0);
+}
+
+void DrawMoneyBox(int amount, u8 x, u8 y)
+{
+    struct WindowTemplate template;
+
+    SetWindowTemplateFields(&template, 0, x + 1, y + 1, 10, 2, 15, 8);
+    sMoneyBoxWindowId = AddWindow(&template);
+    FillWindowPixelBuffer(sMoneyBoxWindowId, 0);
+    PutWindowTilemap(sMoneyBoxWindowId);
+    CopyWindowToVram(sMoneyBoxWindowId, 1);
+    PrintMoneyAmountInMoneyBoxWithBorder(sMoneyBoxWindowId, 0x214, 14, amount);
+    AddMoneyLabelObject((8 * x) + 19, (8 * y) + 11);
+}
+
+void HideMoneyBox(void)
+{
+    RemoveMoneyLabelObject();
+    sub_8198070(sMoneyBoxWindowId, FALSE);
+    CopyWindowToVram(sMoneyBoxWindowId, 2);
+    RemoveWindow(sMoneyBoxWindowId);
+}
+
+void AddMoneyLabelObject(u16 x, u16 y)
+{
+    LoadCompressedObjectPic(&sSpriteSheet_MoneyLabel);
+    LoadCompressedObjectPalette(&sSpritePalette_MoneyLabel);
+    sMoneyLabelSpriteId = CreateSprite(&sSpriteTemplate_MoneyLabel, x, y, 0);
+}
+
+void RemoveMoneyLabelObject(void)
+{
+    DestroySpriteAndFreeResources(&gSprites[sMoneyLabelSpriteId]);
+}

src/new_game.c

@@ -17,6 +17,7 @@
 #include "easy_chat.h"
 #include "event_data.h"
 #include "money.h"
+#include "tv.h"
 #include "coins.h"
 #include "text.h"
 
@@ -28,7 +29,7 @@ extern u8 gUnknown_030060B0;
 // TODO: replace those declarations with file headers
 extern u16 GetGeneratedTrainerIdLower(void);
 extern void ClearContestWinnerPicsInContestHall(void);
-extern void warp1_set(s8 mapBank, s8 mapNo, s8 warpNo, s8 xPos, s8 yPos);
+extern void Overworld_SetWarpDestination(s8 mapBank, s8 mapNo, s8 warpNo, s8 xPos, s8 yPos);
 extern void warp_in(void);
 extern void sub_80BB358(void);
 extern void ResetBagScrollPositions(void);
@@ -36,7 +37,6 @@ extern void sub_813624C(void); // clears something pokeblock related
 extern void ResetPokedex(void);
 extern void sub_8084400(void);
 extern void ClearMailData(void);
-extern void ClearTVShowData(void);
 extern void ResetGabbyAndTy(void);
 extern void ResetSecretBases(void);
 extern void ResetLinkContestBoolean(void);
@@ -131,7 +131,7 @@ void sub_8084400(void)
 
 void WarpToTruck(void)
 {
-    warp1_set(25, 40, -1, -1, -1); // inside of truck
+    Overworld_SetWarpDestination(25, 40, -1, -1, -1); // inside of truck
     warp_in();
 }
 

src/palette.c

@@ -1,5 +1,8 @@
 #include "global.h"
+#include "blend_palette.h"
 #include "palette.h"
+#include "decompress.h"
+#include "gpu_regs.h"
 #include "task.h"
 
 enum
@@ -28,7 +31,7 @@ struct PaletteStructTemplate
 
 struct PaletteStruct
 {
-    struct PaletteStructTemplate *base;
+    const struct PaletteStructTemplate *base;
     u32 ps_field_4_0:1;
     u16 ps_field_4_1:1;
     u32 baseDestOffset:9;
@@ -38,31 +41,6 @@ struct PaletteStruct
     u8 ps_field_9;
 };
 
-extern void LZDecompressWram(const void *src, void *dest);
-extern void SetGpuReg(u8 regOffset, u16 value);
-extern void sub_8149DFC(u8 a1);
-extern void sub_80A1670(u16 a1);
-extern void sub_80A2D54(u8 a1);
-extern void SetWordTaskArg(u8 taskId, u8 dataElem, u32 value);
-extern void _call_via_r1(u32 a1, void *a2);
-
-extern void BlendPalette(u16, u16, u8, u16);
-
-EWRAM_DATA u16 gPlttBufferUnfaded[0x200] = {0};
-EWRAM_DATA u16 gPlttBufferFaded[0x200] = {0};
-EWRAM_DATA struct PaletteStruct sPaletteStructs[0x10] = {0};
-EWRAM_DATA struct PaletteFadeControl gPaletteFade = {0};
-EWRAM_DATA u32 gFiller_2037FE0 = 0;
-EWRAM_DATA u32 sPlttBufferTransferPending = 0;
-EWRAM_DATA u8 gPaletteDecompressionBuffer[0x400] = {0};
-
-extern struct PaletteStructTemplate gDummyPaletteStructTemplate;
-extern void *gUnknown_0852487C;
-extern u8 gUnknown_0852489C[];
-
-extern u16 gUnknown_03000F3C;
-extern void *gUnknown_03000F44;
-
 static void unused_sub_80A1CDC(struct PaletteStruct *, u32 *);
 static void unused_sub_80A1E40(struct PaletteStruct *, u32 *);
 static void unused_sub_80A1F00(struct PaletteStruct *);
@@ -73,32 +51,29 @@ static u8 UpdateFastPaletteFade(void);
 static u8 UpdateHardwarePaletteFade(void);
 static void UpdateBlendRegisters(void);
 static bool8 IsSoftwarePaletteFadeFinishing(void);
+static void sub_80A2D54(u8 taskId);
 
-void sub_80A1818(u16 a1)
-{
-  void **v1 = &gUnknown_0852487C;
-  CpuSet(v1[a1 & 0x3], gPlttBufferUnfaded + 0x80, 0x10);
-  BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF);
-  if ((u8)FindTaskIdByFunc(sub_8149DFC) != 0xFF )
-  {
-    gUnknown_03000F44 = sub_80A1670;
-    gUnknown_03000F3C = 0x20;
-  }
-  return;
-}
+EWRAM_DATA u16 gPlttBufferUnfaded[PLTT_BUFFER_SIZE] = {0};
+EWRAM_DATA u16 gPlttBufferFaded[PLTT_BUFFER_SIZE] = {0};
+EWRAM_DATA struct PaletteStruct sPaletteStructs[0x10] = {0};
+EWRAM_DATA struct PaletteFadeControl gPaletteFade = {0};
+static EWRAM_DATA u32 gFiller_2037FE0 = 0;
+static EWRAM_DATA u32 sPlttBufferTransferPending = 0;
+EWRAM_DATA u8 gPaletteDecompressionBuffer[PLTT_DECOMP_BUFFER_SIZE] = {0};
 
-void sub_80A1884(u16 a1)
-{
-  void **v1 = &gUnknown_0852487C;
-  CpuSet(v1[a1 & 0x3], gPlttBufferUnfaded + 0x80, 0x10);
-  if ((u8)FindTaskIdByFunc(sub_8149DFC) == 0xFF )
-  {
-    BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF);
-    if (!--gUnknown_03000F3C)
-        gUnknown_03000F44 = 0;
-  }
-  return;
-}
+static const struct PaletteStructTemplate gDummyPaletteStructTemplate = {
+    .uid = 0xFFFF,
+    .pst_field_B_5 = 1
+};
+static const u8 gUnknown_0852489C[] = {
+     0,  0,  0,  0,  0,
+     5,  5,  5,  5,  5,
+    11, 11, 11, 11, 11,
+    16, 16, 16, 16, 16,
+    21, 21, 21, 21, 21,
+    27, 27, 27, 27, 27,
+    31, 31
+};
 
 void LoadCompressedPalette(const void *src, u16 offset, u16 size)
 {

src/pokemon_1.c

@@ -33,7 +33,7 @@ void ZeroMonData(struct Pokemon *mon)
     SetMonData(mon, MON_DATA_MAX_HP, &arg);
     SetMonData(mon, MON_DATA_ATK, &arg);
     SetMonData(mon, MON_DATA_DEF, &arg);
-    SetMonData(mon, MON_DATA_SPD, &arg);
+    SetMonData(mon, MON_DATA_SPEED, &arg);
     SetMonData(mon, MON_DATA_SPATK, &arg);
     SetMonData(mon, MON_DATA_SPDEF, &arg);
     arg = 255;
@@ -128,7 +128,7 @@ void CreateBoxMon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV,
         SetBoxMonData(boxMon, MON_DATA_HP_IV, &fixedIV);
         SetBoxMonData(boxMon, MON_DATA_ATK_IV, &fixedIV);
         SetBoxMonData(boxMon, MON_DATA_DEF_IV, &fixedIV);
-        SetBoxMonData(boxMon, MON_DATA_SPD_IV, &fixedIV);
+        SetBoxMonData(boxMon, MON_DATA_SPEED_IV, &fixedIV);
         SetBoxMonData(boxMon, MON_DATA_SPATK_IV, &fixedIV);
         SetBoxMonData(boxMon, MON_DATA_SPDEF_IV, &fixedIV);
     }
@@ -147,7 +147,7 @@ void CreateBoxMon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV,
         value = Random();
 
         iv = value & 0x1F;
-        SetBoxMonData(boxMon, MON_DATA_SPD_IV, &iv);
+        SetBoxMonData(boxMon, MON_DATA_SPEED_IV, &iv);
         iv = (value & 0x3E0) >> 5;
         SetBoxMonData(boxMon, MON_DATA_SPATK_IV, &iv);
         iv = (value & 0x7C00) >> 10;
@@ -234,7 +234,7 @@ void CreateMonWithIVsOTID(struct Pokemon *mon, u16 species, u8 level, u8 *ivs, u
     SetMonData(mon, MON_DATA_HP_IV, &ivs[0]);
     SetMonData(mon, MON_DATA_ATK_IV, &ivs[1]);
     SetMonData(mon, MON_DATA_DEF_IV, &ivs[2]);
-    SetMonData(mon, MON_DATA_SPD_IV, &ivs[3]);
+    SetMonData(mon, MON_DATA_SPEED_IV, &ivs[3]);
     SetMonData(mon, MON_DATA_SPATK_IV, &ivs[4]);
     SetMonData(mon, MON_DATA_SPDEF_IV, &ivs[5]);
     CalculateMonStats(mon);
@@ -305,7 +305,7 @@ void sub_806819C(struct Pokemon *mon, struct UnknownPokemonStruct *src)
     SetMonData(mon, MON_DATA_HP_EV, &src->hpEV);
     SetMonData(mon, MON_DATA_ATK_EV, &src->attackEV);
     SetMonData(mon, MON_DATA_DEF_EV, &src->defenseEV);
-    SetMonData(mon, MON_DATA_SPD_EV, &src->speedEV);
+    SetMonData(mon, MON_DATA_SPEED_EV, &src->speedEV);
     SetMonData(mon, MON_DATA_SPATK_EV, &src->spAttackEV);
     SetMonData(mon, MON_DATA_SPDEF_EV, &src->spDefenseEV);
     value = src->altAbility;
@@ -317,7 +317,7 @@ void sub_806819C(struct Pokemon *mon, struct UnknownPokemonStruct *src)
     value = src->defenseIV;
     SetMonData(mon, MON_DATA_DEF_IV, &value);
     value = src->speedIV;
-    SetMonData(mon, MON_DATA_SPD_IV, &value);
+    SetMonData(mon, MON_DATA_SPEED_IV, &value);
     value = src->spAttackIV;
     SetMonData(mon, MON_DATA_SPATK_IV, &value);
     value = src->spDefenseIV;
@@ -369,7 +369,7 @@ void sub_8068338(struct Pokemon *mon, struct UnknownPokemonStruct *src, bool8 lv
     SetMonData(mon, MON_DATA_HP_EV, &src->hpEV);
     SetMonData(mon, MON_DATA_ATK_EV, &src->attackEV);
     SetMonData(mon, MON_DATA_DEF_EV, &src->defenseEV);
-    SetMonData(mon, MON_DATA_SPD_EV, &src->speedEV);
+    SetMonData(mon, MON_DATA_SPEED_EV, &src->speedEV);
     SetMonData(mon, MON_DATA_SPATK_EV, &src->spAttackEV);
     SetMonData(mon, MON_DATA_SPDEF_EV, &src->spDefenseEV);
     value = src->altAbility;
@@ -381,7 +381,7 @@ void sub_8068338(struct Pokemon *mon, struct UnknownPokemonStruct *src, bool8 lv
     value = src->defenseIV;
     SetMonData(mon, MON_DATA_DEF_IV, &value);
     value = src->speedIV;
-    SetMonData(mon, MON_DATA_SPD_IV, &value);
+    SetMonData(mon, MON_DATA_SPEED_IV, &value);
     value = src->spAttackIV;
     SetMonData(mon, MON_DATA_SPATK_IV, &value);
     value = src->spDefenseIV;

src/pokemon_2.c

@@ -28,14 +28,14 @@ extern const u32 gBitTable[];
 extern const struct SpriteTemplate gUnknown_08329D98[];
 extern const struct SpriteTemplate gUnknown_08329DF8[];
 extern const union AnimCmd* gUnknown_082FF70C[];
-extern const union AnimCmd* const * const gUnknown_08309AAC[];
+extern const union AnimCmd* const * const gMonAnimationsSpriteAnimsPtrTable[];
 extern const union AnimCmd* const * const gUnknown_08305D0C[];
 extern const union AnimCmd* const * const gUnknown_0830536C[];
 extern const u8 gText_BadEgg[];
 extern const u8 gText_EggNickname[];
 
 extern u8 GetBankSide(u8 bank);
-extern u8 GetBankByPlayerAI(u8 bank);
+extern u8 GetBankByIdentity(u8 bank);
 extern u8 GetBankIdentity(u8 bank);
 
 u8 CountAliveMonsInBattle(u8 caseId)
@@ -90,7 +90,7 @@ u8 sub_8069F34(u8 bank)
 
     status ^= 1;
     if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
-        return GetBankByPlayerAI(status);
+        return GetBankByIdentity(status);
     if (CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) > 1)
     {
         u8 val;
@@ -99,14 +99,14 @@ u8 sub_8069F34(u8 bank)
             val = status ^ 2;
         else
             val = status;
-        return GetBankByPlayerAI(val);
+        return GetBankByIdentity(val);
     }
     else
     {
         if ((gAbsentBankFlags & gBitTable[status]))
-            return GetBankByPlayerAI(status ^ 2);
+            return GetBankByIdentity(status ^ 2);
         else
-            return GetBankByPlayerAI(status);
+            return GetBankByIdentity(status);
     }
 }
 
@@ -152,8 +152,8 @@ u8 GetGenderFromSpeciesAndPersonality(u16 species, u32 personality)
 
 void sub_806A068(u16 species, u8 bankIdentity)
 {
-    if (gBattleSpritesGfx != NULL)
-        gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+    if (gMonSpritesGfxPtr != NULL)
+        gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
     else if (gUnknown_020249B4[0])
         gUnknown_0202499C = gUnknown_020249B4[0]->templates[bankIdentity];
     else if (gUnknown_020249B4[1])
@@ -165,9 +165,9 @@ void sub_806A068(u16 species, u8 bankIdentity)
     if (bankIdentity == 0 || bankIdentity == 2)
         gUnknown_0202499C.anims = gUnknown_082FF70C;
     else if (species > 500)
-        gUnknown_0202499C.anims = gUnknown_08309AAC[species - 500];
+        gUnknown_0202499C.anims = gMonAnimationsSpriteAnimsPtrTable[species - 500];
     else
-        gUnknown_0202499C.anims = gUnknown_08309AAC[species];
+        gUnknown_0202499C.anims = gMonAnimationsSpriteAnimsPtrTable[species];
 }
 
 void sub_806A12C(u16 trainerSpriteId, u8 bankIdentity)
@@ -180,8 +180,8 @@ void sub_806A12C(u16 trainerSpriteId, u8 bankIdentity)
     }
     else
     {
-        if (gBattleSpritesGfx != NULL)
-            gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+        if (gMonSpritesGfxPtr != NULL)
+            gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
         else
             gUnknown_0202499C = gUnknown_08329D98[bankIdentity];
         gUnknown_0202499C.anims = gUnknown_0830536C[trainerSpriteId];
@@ -190,8 +190,8 @@ void sub_806A12C(u16 trainerSpriteId, u8 bankIdentity)
 
 void sub_806A1C0(u16 arg0, u8 bankIdentity)
 {
-    if (gBattleSpritesGfx != NULL)
-        gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+    if (gMonSpritesGfxPtr != NULL)
+        gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
     else
         gUnknown_0202499C = gUnknown_08329D98[bankIdentity];
     gUnknown_0202499C.paletteTag = arg0;
@@ -330,7 +330,7 @@ u32 GetMonData(struct Pokemon *mon, s32 field, u8* data)
         if (!ret)
             ret = mon->defense;
         break;
-    case MON_DATA_SPD:
+    case MON_DATA_SPEED:
         ret = GetDeoxysStat(mon, STAT_SPD);
         if (!ret)
             ret = mon->speed;
@@ -351,7 +351,7 @@ u32 GetMonData(struct Pokemon *mon, s32 field, u8* data)
     case MON_DATA_DEF2:
         ret = mon->defense;
         break;
-    case MON_DATA_SPD2:
+    case MON_DATA_SPEED2:
         ret = mon->speed;
         break;
     case MON_DATA_SPATK2:
@@ -512,7 +512,7 @@ u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data)
     case MON_DATA_DEF_EV:
         retVal = substruct2->defenseEV;
         break;
-    case MON_DATA_SPD_EV:
+    case MON_DATA_SPEED_EV:
         retVal = substruct2->speedEV;
         break;
     case MON_DATA_SPATK_EV:
@@ -566,7 +566,7 @@ u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data)
     case MON_DATA_DEF_IV:
         retVal = substruct3->defenseIV;
         break;
-    case MON_DATA_SPD_IV:
+    case MON_DATA_SPEED_IV:
         retVal = substruct3->speedIV;
         break;
     case MON_DATA_SPATK_IV:
@@ -747,7 +747,7 @@ void SetMonData(struct Pokemon *mon, s32 field, const void *dataArg)
     case MON_DATA_DEF:
         SET16(mon->defense);
         break;
-    case MON_DATA_SPD:
+    case MON_DATA_SPEED:
         SET16(mon->speed);
         break;
     case MON_DATA_SPATK:
@@ -880,7 +880,7 @@ void SetBoxMonData(struct BoxPokemon *boxMon, s32 field, const void *dataArg)
     case MON_DATA_DEF_EV:
         SET8(substruct2->defenseEV);
         break;
-    case MON_DATA_SPD_EV:
+    case MON_DATA_SPEED_EV:
         SET8(substruct2->speedEV);
         break;
     case MON_DATA_SPATK_EV:
@@ -940,7 +940,7 @@ void SetBoxMonData(struct BoxPokemon *boxMon, s32 field, const void *dataArg)
     case MON_DATA_DEF_IV:
         SET8(substruct3->defenseIV);
         break;
-    case MON_DATA_SPD_IV:
+    case MON_DATA_SPEED_IV:
         SET8(substruct3->speedIV);
         break;
     case MON_DATA_SPATK_IV:
@@ -1089,7 +1089,7 @@ u8 SendMonToPC(struct Pokemon* mon)
                 gSpecialVar_0x8012 = boxNo;
                 gSpecialVar_0x8013 = boxPos;
                 if (get_unknown_box_id() != boxNo)
-                    FlagReset(SYS_STORAGE_UNKNOWN_FLAG);
+                    FlagClear(SYS_STORAGE_UNKNOWN_FLAG);
                 VarSet(VAR_STORAGE_UNKNOWN, boxNo);
                 return MON_GIVEN_TO_PC;
             }
@@ -1308,10 +1308,9 @@ void sub_805EF84(u8 bank, bool8);
 
 extern struct BattlePokemon gBattleMons[4];
 
-/*
-
 void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
 {
+    u16* hpSwitchout;
     s32 i;
     u8 nickname[POKEMON_NAME_LENGTH * 2];
 
@@ -1330,7 +1329,7 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
     gBattleMons[bank].hpIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HP_IV, NULL);
     gBattleMons[bank].attackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK_IV, NULL);
     gBattleMons[bank].defenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF_IV, NULL);
-    gBattleMons[bank].speedIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPD_IV, NULL);
+    gBattleMons[bank].speedIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED_IV, NULL);
     gBattleMons[bank].spAttackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK_IV, NULL);
     gBattleMons[bank].spDefenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF_IV, NULL);
     gBattleMons[bank].personality = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PERSONALITY, NULL);
@@ -1340,7 +1339,7 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
     gBattleMons[bank].maxHP = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MAX_HP, NULL);
     gBattleMons[bank].attack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK, NULL);
     gBattleMons[bank].defense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF, NULL);
-    gBattleMons[bank].speed = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPD, NULL);
+    gBattleMons[bank].speed = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED, NULL);
     gBattleMons[bank].spAttack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK, NULL);
     gBattleMons[bank].spDefense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF, NULL);
     gBattleMons[bank].isEgg = GetMonData(&gPlayerParty[partyIndex], MON_DATA_IS_EGG, NULL);
@@ -1352,15 +1351,9 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
     GetMonData(&gPlayerParty[partyIndex], MON_DATA_NICKNAME, nickname);
     StringCopy10(gBattleMons[bank].nickname, nickname);
     GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_NAME, gBattleMons[bank].otName);
-    // ewram memes from Ruby return
-    #ifdef NONMATCHING
-        gBattleStruct->hpOnSwitchout[GetBankSide(bank)] = gBattleMons[bank].hp;
-    #else
-        {
-            u32 side = GetBankSide(bank);
-            *(u16*)((void*)(gBattleStruct) + side) = gBattleMons[bank].hp;
-        }
-    #endif // NONMATCHING
+
+    hpSwitchout = &gBattleStruct->hpOnSwitchout[GetBankSide(bank)];
+    *hpSwitchout = gBattleMons[bank].hp;
 
     for (i = 0; i < 8; i++)
         gBattleMons[bank].statStages[i] = 6;
@@ -1369,4 +1362,3 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex)
     sub_803FA70(bank);
     sub_805EF84(bank, FALSE);
 }
-*/

src/pokemon_3.c

@@ -216,7 +216,7 @@ void sub_806CF24(s32 stat)
     gBankTarget = gBankInMenu;
     StringCopy(gBattleTextBuff1, gStatNamesTable[gUnknown_08329EC8[stat]]);
     StringCopy(gBattleTextBuff2, gText_StatRose);
-    StrCpyDecodeToDisplayedStringBattle(gText_PkmnsStatChanged2);
+    BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnsStatChanged2);
 }
 
 u8 *sub_806CF78(u16 itemId)
@@ -251,7 +251,7 @@ u8 *sub_806CF78(u16 itemId)
             else
             {
                 gBankAttacker = gBankInMenu;
-                StrCpyDecodeToDisplayedStringBattle(gText_PkmnGettingPumped);
+                BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnGettingPumped);
             }
         }
     }
@@ -259,7 +259,7 @@ u8 *sub_806CF78(u16 itemId)
     if (itemEffect[3] & 0x80)
     {
         gBankAttacker = gBankInMenu;
-        StrCpyDecodeToDisplayedStringBattle(gText_PkmnShroudedInMist);
+        BattleStringExpandPlaceholdersToDisplayedString(gText_PkmnShroudedInMist);
     }
 
     return gDisplayedStringBattle;
@@ -486,8 +486,8 @@ u16 SpeciesToCryId(u16 species)
 void sub_806D544(u16 species, u32 personality, u8 *dest)
 {
     if (species == SPECIES_SPINDA
-        && dest != gBattleSpritesGfx->sprites[0]
-        && dest != gBattleSpritesGfx->sprites[2])
+        && dest != gMonSpritesGfxPtr->sprites[0]
+        && dest != gMonSpritesGfxPtr->sprites[2])
     {
         int i;
         for (i = 0; i < 4; i++)
@@ -601,9 +601,9 @@ bool8 sub_806D7EC(void)
     return retVal;
 }
 
-bool8 sub_806D82C(u8 id)
+bool16 sub_806D82C(u8 id)
 {
-    bool8 retVal = FALSE;
+    bool16 retVal = FALSE;
     switch (gLinkPlayers[id].lp_field_18)
     {
     case 0:
@@ -1361,20 +1361,20 @@ void BoxMonRestorePP(struct BoxPokemon *boxMon)
 void sub_806E994(void)
 {
     gLastUsedAbility = gBattleStruct->field_B0;
-    gBattleTextBuff1[0] = 0xFD;
-    gBattleTextBuff1[1] = 4;
+
+    gBattleTextBuff1[0] = B_BUFF_PLACEHOLDER_BEGIN;
+    gBattleTextBuff1[1] = B_BUFF_MON_NICK_WITH_PREFIX;
     gBattleTextBuff1[2] = gBattleStruct->field_49;
-    gBattleTextBuff1[4] = EOS;
+    gBattleTextBuff1[4] = B_BUFF_EOS;
+
     if (!GetBankSide(gBattleStruct->field_49))
         gBattleTextBuff1[3] = pokemon_order_func(gBattlePartyID[gBattleStruct->field_49]);
     else
         gBattleTextBuff1[3] = gBattlePartyID[gBattleStruct->field_49];
-    gBattleTextBuff2[0] = 0xFD;
-    gBattleTextBuff2[1] = 4;
-    gBattleTextBuff2[2] = gBankInMenu;
-    gBattleTextBuff2[3] = pokemon_order_func(gBattlePartyID[gBankInMenu]);
-    gBattleTextBuff2[4] = EOS;
-    StrCpyDecodeBattle(gText_PkmnsXPreventsSwitching, gStringVar4);
+
+    PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff2, gBankInMenu, pokemon_order_func(gBattlePartyID[gBankInMenu]))
+
+    BattleStringExpandPlaceholders(gText_PkmnsXPreventsSwitching, gStringVar4);
 }
 
 struct PokeItem
@@ -1388,7 +1388,7 @@ extern const struct PokeItem gAlteringCaveWildMonHeldItems[9];
 static s32 GetWildMonTableIdInAlteringCave(u16 species)
 {
     s32 i;
-    for (i = 0; i < 9; i++)
+    for (i = 0; i < (s32) ARRAY_COUNT(gAlteringCaveWildMonHeldItems); i++)
         if (gAlteringCaveWildMonHeldItems[i].species == species)
             return i;
     return 0;
@@ -1519,8 +1519,6 @@ void BattleAnimateFrontSprite(struct Sprite* sprite, u16 species, bool8 noCry, u
         DoMonFrontSpriteAnimation(sprite, species, noCry, arg3);
 }
 
-bool8 HasTwoFramesAnimation(u16 species);
-
 extern void SpriteCallbackDummy_2(struct Sprite*);
 extern void sub_817F60C(struct Sprite*);
 

src/pokemon_size_record.c

@@ -57,7 +57,7 @@ static u32 GetMonSizeHash(struct Pokemon *pkmn)
     u16 hpIV = GetMonData(pkmn, MON_DATA_HP_IV) & 0xF;
     u16 attackIV = GetMonData(pkmn, MON_DATA_ATK_IV) & 0xF;
     u16 defenseIV = GetMonData(pkmn, MON_DATA_DEF_IV) & 0xF;
-    u16 speedIV = GetMonData(pkmn, MON_DATA_SPD_IV) & 0xF;
+    u16 speedIV = GetMonData(pkmn, MON_DATA_SPEED_IV) & 0xF;
     u16 spAtkIV = GetMonData(pkmn, MON_DATA_SPATK_IV) & 0xF;
     u16 spDefIV = GetMonData(pkmn, MON_DATA_SPDEF_IV) & 0xF;
     u32 hibyte = ((attackIV ^ defenseIV) * hpIV) ^ (personality & 0xFF);

src/pokemon_storage_system.c

@@ -0,0 +1,15 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u8 gUnknown_03000F78[0x188];
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/record_mixing.c

@@ -0,0 +1,28 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA bool8 gUnknown_03001130;
+IWRAM_DATA struct SecretBaseRecord *gUnknown_03001134;
+IWRAM_DATA TVShow *gUnknown_03001138;
+IWRAM_DATA struct UnknownSaveStruct2ABC *gUnknown_0300113C;
+IWRAM_DATA OldMan *gUnknown_03001140;
+IWRAM_DATA struct EasyChatPair *gUnknown_03001144;
+IWRAM_DATA struct DaycareData *gUnknown_03001148;
+IWRAM_DATA void *gUnknown_0300114C; // gSaveBlock2Ptr->field_64C
+IWRAM_DATA LilycoveLady *gUnknown_03001150;
+IWRAM_DATA void *gUnknown_03001154; // gSaveBlock2Ptr->field_0DC;
+IWRAM_DATA void *gUnknown_03001158; // gSaveBlock2Ptr->field_64C
+IWRAM_DATA u32 gUnknown_0300115C;
+IWRAM_DATA u8 gUnknown_03001160[8];
+IWRAM_DATA u32 gUnknown_03001168[3];
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/reset_save_heap.c

@@ -5,7 +5,7 @@
 #include "load_save.h"
 #include "save.h"
 #include "new_game.h"
-#include "rom4.h"
+#include "overworld.h"
 #include "malloc.h"
 
 void sub_81700F8(void)

src/reshow_battle_screen.c

@@ -0,0 +1,354 @@
+#include "global.h"
+#include "reshow_battle_screen.h"
+#include "battle.h"
+#include "palette.h"
+#include "main.h"
+#include "unknown_task.h"
+#include "text.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "battle_controllers.h"
+#include "link.h"
+#include "sprite.h"
+#include "species.h"
+#include "battle_interface.h"
+
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG0_Y;
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_X;
+extern u16 gBattle_BG2_Y;
+extern u16 gBattle_BG3_X;
+extern u16 gBattle_BG3_Y;
+extern u8 gReservedSpritePaletteCount;
+extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gBankInMenu;
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u8 gNoOfAllBanks;
+extern u32 gBattleTypeFlags;
+extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
+extern u8 gBattleMonForms[BATTLE_BANKS_COUNT];
+extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+extern struct SpriteTemplate gUnknown_0202499C;
+
+extern const union AnimCmd * const * const gMonAnimationsSpriteAnimsPtrTable[];
+
+extern void dp12_8087EA4(void);
+extern void trs_config(void);
+extern bool8 IsDoubleBattle(void);
+extern u8 sub_80A614C(u8 bank);
+extern u8 sub_80A6138(u8 bank);
+extern u8 sub_80A82E4(u8 bank);
+extern void sub_806A068(u16 species, u8 bankIdentity);
+extern void sub_806A12C(u16 backPicId, u8 bankIdentity);
+extern u8 sub_80A5C6C(u8 bank, u8 caseId);
+
+// this file's functions
+static void CB2_ReshowBattleScreenAfterMenu(void);
+static bool8 LoadBankSpriteGfx(u8 bank);
+static void CreateBankSprite(u8 bank);
+static void CreateHealthboxSprite(u8 bank);
+static void sub_80A95F4(void);
+
+void nullsub_35(void)
+{
+
+}
+
+void ReshowBattleScreenAfterMenu(void)
+{
+    gPaletteFade.bufferTransferDisabled = 1;
+    SetHBlankCallback(NULL);
+    SetVBlankCallback(NULL);
+    SetGpuReg(REG_OFFSET_MOSAIC, 0);
+    gBattleScripting.reshowMainState = 0;
+    gBattleScripting.reshowHelperState = 0;
+    SetMainCallback2(CB2_ReshowBattleScreenAfterMenu);
+}
+
+static void CB2_ReshowBattleScreenAfterMenu(void)
+{
+    switch (gBattleScripting.reshowMainState)
+    {
+    case 0:
+        dp12_8087EA4();
+        trs_config();
+        SetBgAttribute(1, BG_CTRL_ATTR_VISIBLE, 0);
+        SetBgAttribute(2, BG_CTRL_ATTR_VISIBLE, 0);
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(2);
+        ShowBg(3);
+        ResetPaletteFade();
+        gBattle_BG0_X = 0;
+        gBattle_BG0_Y = 0;
+        gBattle_BG1_X = 0;
+        gBattle_BG1_Y = 0;
+        gBattle_BG2_X = 0;
+        gBattle_BG2_Y = 0;
+        gBattle_BG3_X = 0;
+        gBattle_BG3_Y = 0;
+        break;
+    case 1:
+        CpuFastFill(0, (void*)(VRAM), VRAM_SIZE);
+        break;
+    case 2:
+        LoadBattleTextboxAndBackground();
+        break;
+    case 3:
+        ResetSpriteData();
+        break;
+    case 4:
+        FreeAllSpritePalettes();
+        gReservedSpritePaletteCount = 4;
+        break;
+    case 5:
+        sub_805E350();
+        break;
+    case 6:
+        if (BattleLoadAllHealthBoxesGfx(gBattleScripting.reshowHelperState))
+        {
+            gBattleScripting.reshowHelperState = 0;
+        }
+        else
+        {
+            gBattleScripting.reshowHelperState++;
+            gBattleScripting.reshowMainState--;
+        }
+        break;
+    case 7:
+        if (!LoadBankSpriteGfx(0))
+            gBattleScripting.reshowMainState--;
+        break;
+    case 8:
+        if (!LoadBankSpriteGfx(1))
+            gBattleScripting.reshowMainState--;
+        break;
+    case 9:
+        if (!LoadBankSpriteGfx(2))
+            gBattleScripting.reshowMainState--;
+        break;
+    case 10:
+        if (!LoadBankSpriteGfx(3))
+            gBattleScripting.reshowMainState--;
+        break;
+    case 11:
+        CreateBankSprite(0);
+        break;
+    case 12:
+        CreateBankSprite(1);
+        break;
+    case 13:
+        CreateBankSprite(2);
+        break;
+    case 14:
+        CreateBankSprite(3);
+        break;
+    case 15:
+        CreateHealthboxSprite(0);
+        break;
+    case 16:
+        CreateHealthboxSprite(1);
+        break;
+    case 17:
+        CreateHealthboxSprite(2);
+        break;
+    case 18:
+        CreateHealthboxSprite(3);
+        break;
+    case 19:
+        {
+            u8 opponentBank;
+            u16 species;
+
+            LoadAndCreateEnemyShadowSprites();
+
+            opponentBank = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+            species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES);
+            SetBankEnemyShadowSpriteCallback(opponentBank, species);
+
+            if (IsDoubleBattle())
+            {
+                opponentBank = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+                species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES);
+                SetBankEnemyShadowSpriteCallback(opponentBank, species);
+            }
+
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gBankInMenu], 0);
+
+            if (gLinkVSyncDisabled != 0 && gReceivedRemoteLinkPlayers != 0)
+            {
+                sub_800E0E8();
+                sub_800DFB4(0, 0);
+            }
+        }
+        break;
+    default:
+        SetVBlankCallback(VBlankCB_Battle);
+        sub_80A95F4();
+        BeginHardwarePaletteFade(0xFF, 0, 0x10, 0, 1);
+        gPaletteFade.bufferTransferDisabled = 0;
+        SetMainCallback2(BattleMainCB2);
+        sub_805EF14();
+        break;
+    }
+
+    gBattleScripting.reshowMainState++;
+}
+
+static void sub_80A95F4(void)
+{
+    struct BGCntrlBitfield *regBgcnt1, *regBgcnt2;
+
+    regBgcnt1 = (struct BGCntrlBitfield *)(&REG_BG1CNT);
+    regBgcnt1->charBaseBlock = 0;
+
+    regBgcnt2 = (struct BGCntrlBitfield *)(&REG_BG2CNT);
+    regBgcnt2->charBaseBlock = 0;
+}
+
+static bool8 LoadBankSpriteGfx(u8 bank)
+{
+    if (bank < gNoOfAllBanks)
+    {
+        if (GetBankSide(bank) != SIDE_PLAYER)
+        {
+            if (!gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
+                BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank);
+            else
+                BattleLoadSubstituteSpriteGfx(bank, FALSE);
+        }
+        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
+            LoadBackTrainerBankSpriteGfx(gSaveBlock2Ptr->playerGender, bank);
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
+            LoadBackTrainerBankSpriteGfx(BACK_PIC_WALLY, bank);
+        else if (!gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
+            BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[bank]], bank);
+        else
+            BattleLoadSubstituteSpriteGfx(bank, FALSE);
+
+        gBattleScripting.reshowHelperState = 0;
+    }
+    return TRUE;
+}
+
+// todo: get rid of it once the struct is declared in a header
+struct MonCoords
+{
+    // This would use a bitfield, but sub_8079F44
+    // uses it as a u8 and casting won't match.
+    u8 coords; // u8 x:4, y:4;
+    u8 y_offset;
+};
+extern const struct MonCoords gTrainerBackPicCoords[];
+
+static void CreateBankSprite(u8 bank)
+{
+    if (bank < gNoOfAllBanks)
+    {
+        u8 posY;
+
+        if (gBattleSpritesDataPtr->bankData[bank].behindSubstitute)
+            posY = sub_80A614C(bank);
+        else
+            posY = sub_80A6138(bank);
+
+        if (GetBankSide(bank) != SIDE_PLAYER)
+        {
+            if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+                return;
+
+            sub_806A068(GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank));
+            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, sub_80A5C6C(bank, 2), posY, sub_80A82E4(bank));
+            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
+            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
+            gSprites[gBankSpriteIds[bank]].data0 = bank;
+            gSprites[gBankSpriteIds[bank]].data2 = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES);
+
+            StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]);
+            if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_CASTFORM)
+                gSprites[gBankSpriteIds[bank]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
+        }
+        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
+        {
+            sub_806A12C(gSaveBlock2Ptr->playerGender, GetBankIdentity(IDENTITY_PLAYER_MON1));
+            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, 0x50,
+                                                (8 - gTrainerBackPicCoords[gSaveBlock2Ptr->playerGender].coords) * 4 + 80,
+                                                 sub_80A82E4(0));
+            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
+            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
+            gSprites[gBankSpriteIds[bank]].data0 = bank;
+        }
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
+        {
+            sub_806A12C(BACK_PIC_WALLY, GetBankIdentity(0));
+            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, 0x50,
+                                                (8 - gTrainerBackPicCoords[BACK_PIC_WALLY].coords) * 4 + 80,
+                                                 sub_80A82E4(0));
+            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
+            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
+            gSprites[gBankSpriteIds[bank]].data0 = bank;
+        }
+        else
+        {
+            if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+                return;
+
+            sub_806A068(GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank));
+            gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, sub_80A5C6C(bank, 2), posY, sub_80A82E4(bank));
+            gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
+            gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
+            gSprites[gBankSpriteIds[bank]].data0 = bank;
+            gSprites[gBankSpriteIds[bank]].data2 = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES);
+
+            StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]);
+            if (gBattleSpritesDataPtr->bankData[bank].transformSpecies == SPECIES_CASTFORM)
+                gSprites[gBankSpriteIds[bank]].anims = gMonAnimationsSpriteAnimsPtrTable[SPECIES_CASTFORM];
+        }
+
+        gSprites[gBankSpriteIds[bank]].invisible = gBattleSpritesDataPtr->bankData[bank].invisible;
+    }
+}
+
+static void CreateHealthboxSprite(u8 bank)
+{
+    if (bank < gNoOfAllBanks)
+    {
+        u8 healthboxSpriteId;
+
+        if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0)
+            healthboxSpriteId = CreateSafariPlayerHealthboxSprites();
+        else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0)
+            return;
+        else
+            healthboxSpriteId = CreateBankHealthboxSprites(bank);
+
+        gHealthBoxesIds[bank] = healthboxSpriteId;
+        SetBankHealthboxSpritePos(bank);
+        SetHealthboxSpriteVisible(healthboxSpriteId);
+
+        if (GetBankSide(bank) != SIDE_PLAYER)
+            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gEnemyParty[gBattlePartyID[bank]], HEALTHBOX_ALL);
+        else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[gBattlePartyID[bank]], HEALTHBOX_SAFARI_ALL_TEXT);
+        else
+            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[gBattlePartyID[bank]], HEALTHBOX_ALL);
+
+        if (GetBankIdentity(bank) == IDENTITY_OPPONENT_MON2 || GetBankIdentity(bank) == IDENTITY_PLAYER_MON2)
+            DummyBattleInterfaceFunc(gHealthBoxesIds[bank], TRUE);
+        else
+            DummyBattleInterfaceFunc(gHealthBoxesIds[bank], FALSE);
+
+        if (GetBankSide(bank) != SIDE_PLAYER)
+        {
+            if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+                SetHealthboxSpriteInvisible(healthboxSpriteId);
+        }
+        else if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI))
+        {
+            if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0)
+                SetHealthboxSpriteInvisible(healthboxSpriteId);
+        }
+    }
+}

src/roamer.c

@@ -0,0 +1,218 @@
+#include "global.h"
+#include "roamer.h"
+#include "pokemon.h"
+#include "rng.h"
+#include "species.h"
+#include "event_data.h"
+
+enum
+{
+    MAP_GRP = 0, // map group
+    MAP_NUM = 1, // map number
+};
+
+EWRAM_DATA static u8 sLocationHistory[3][2] = {0};
+EWRAM_DATA static u8 sRoamerLocation[2] = {0};
+
+static const u8 sRoamerLocations[][6] =
+{
+    { 0x19, 0x1A, 0x20, 0x21, 0x31, 0xFF },
+    { 0x1A, 0x19, 0x20, 0x21, 0xFF, 0xFF },
+    { 0x20, 0x1A, 0x19, 0x21, 0xFF, 0xFF },
+    { 0x21, 0x20, 0x19, 0x1A, 0x22, 0x26 },
+    { 0x22, 0x21, 0x23, 0xFF, 0xFF, 0xFF },
+    { 0x23, 0x22, 0x24, 0xFF, 0xFF, 0xFF },
+    { 0x24, 0x23, 0x25, 0x26, 0xFF, 0xFF },
+    { 0x25, 0x24, 0x26, 0xFF, 0xFF, 0xFF },
+    { 0x26, 0x25, 0x21, 0xFF, 0xFF, 0xFF },
+    { 0x27, 0x24, 0x28, 0x29, 0xFF, 0xFF },
+    { 0x28, 0x27, 0x2A, 0xFF, 0xFF, 0xFF },
+    { 0x29, 0x27, 0x2A, 0xFF, 0xFF, 0xFF },
+    { 0x2A, 0x28, 0x29, 0x2B, 0xFF, 0xFF },
+    { 0x2B, 0x2A, 0x2C, 0xFF, 0xFF, 0xFF },
+    { 0x2C, 0x2B, 0x2D, 0xFF, 0xFF, 0xFF },
+    { 0x2D, 0x2C, 0x2E, 0xFF, 0xFF, 0xFF },
+    { 0x2E, 0x2D, 0x2F, 0xFF, 0xFF, 0xFF },
+    { 0x2F, 0x2E, 0x30, 0xFF, 0xFF, 0xFF },
+    { 0x30, 0x2F, 0x31, 0xFF, 0xFF, 0xFF },
+    { 0x31, 0x30, 0x19, 0xFF, 0xFF, 0xFF },
+    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
+};
+
+void ClearRoamerData(void)
+{
+    memset(&gSaveBlock1Ptr->roamer, 0, sizeof(struct Roamer));
+    (&gSaveBlock1Ptr->roamer)->species = SPECIES_LATIAS;
+}
+
+void ClearRoamerLocationData(void)
+{
+    u8 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        sLocationHistory[i][MAP_GRP] = 0;
+        sLocationHistory[i][MAP_NUM] = 0;
+    }
+
+    sRoamerLocation[MAP_GRP] = 0;
+    sRoamerLocation[MAP_NUM] = 0;
+}
+
+static void CreateInitialRoamerMon(bool16 createLatios)
+{
+    if (!createLatios)
+        (&gSaveBlock1Ptr->roamer)->species = SPECIES_LATIAS;
+    else
+        (&gSaveBlock1Ptr->roamer)->species = SPECIES_LATIOS;
+
+    CreateMon(&gEnemyParty[0], (&gSaveBlock1Ptr->roamer)->species, 40, 0x20, 0, 0, 0, 0);
+    (&gSaveBlock1Ptr->roamer)->level = 40;
+    (&gSaveBlock1Ptr->roamer)->status = 0;
+    (&gSaveBlock1Ptr->roamer)->active = TRUE;
+    (&gSaveBlock1Ptr->roamer)->ivs = GetMonData(&gEnemyParty[0], MON_DATA_IVS);
+    (&gSaveBlock1Ptr->roamer)->personality = GetMonData(&gEnemyParty[0], MON_DATA_PERSONALITY);
+    (&gSaveBlock1Ptr->roamer)->hp = GetMonData(&gEnemyParty[0], MON_DATA_MAX_HP);
+    (&gSaveBlock1Ptr->roamer)->cool = GetMonData(&gEnemyParty[0], MON_DATA_COOL);
+    (&gSaveBlock1Ptr->roamer)->beauty = GetMonData(&gEnemyParty[0], MON_DATA_BEAUTY);
+    (&gSaveBlock1Ptr->roamer)->cute = GetMonData(&gEnemyParty[0], MON_DATA_CUTE);
+    (&gSaveBlock1Ptr->roamer)->smart = GetMonData(&gEnemyParty[0], MON_DATA_SMART);
+    (&gSaveBlock1Ptr->roamer)->tough = GetMonData(&gEnemyParty[0], MON_DATA_TOUGH);
+    sRoamerLocation[MAP_GRP] = 0;
+    sRoamerLocation[MAP_NUM] = sRoamerLocations[Random() % 20][0];
+}
+
+void InitRoamer(void)
+{
+    ClearRoamerData();
+    ClearRoamerLocationData();
+    CreateInitialRoamerMon(gSpecialVar_0x8004);
+}
+
+void UpdateLocationHistoryForRoamer(void)
+{
+    sLocationHistory[2][MAP_GRP] = sLocationHistory[1][MAP_GRP];
+    sLocationHistory[2][MAP_NUM] = sLocationHistory[1][MAP_NUM];
+
+    sLocationHistory[1][MAP_GRP] = sLocationHistory[0][MAP_GRP];
+    sLocationHistory[1][MAP_NUM] = sLocationHistory[0][MAP_NUM];
+
+    sLocationHistory[0][MAP_GRP] = gSaveBlock1Ptr->location.mapGroup;
+    sLocationHistory[0][MAP_NUM] = gSaveBlock1Ptr->location.mapNum;
+}
+
+void RoamerMoveToOtherLocationSet(void)
+{
+    u8 val = 0;
+    struct Roamer *roamer = &gSaveBlock1Ptr->roamer;
+
+    if (!roamer->active)
+        return;
+
+    sRoamerLocation[MAP_GRP] = val;
+
+    while (1)
+    {
+        val = sRoamerLocations[Random() % 20][0];
+        if (sRoamerLocation[MAP_NUM] != val)
+        {
+            sRoamerLocation[MAP_NUM] = val;
+            return;
+        }
+    }
+}
+
+void RoamerMove(void)
+{
+    u8 locSet = 0;
+
+    if ((Random() % 16) == 0)
+    {
+        RoamerMoveToOtherLocationSet();
+    }
+    else
+    {
+        struct Roamer *roamer = &gSaveBlock1Ptr->roamer;
+
+        if (!roamer->active)
+            return;
+
+        while (locSet < 20)
+        {
+            if (sRoamerLocation[MAP_NUM] == sRoamerLocations[locSet][0])
+            {
+                u8 mapNum;
+                while (1)
+                {
+                    mapNum = sRoamerLocations[locSet][(Random() % 5) + 1];
+                    if (!(sLocationHistory[2][MAP_GRP] == 0 && sLocationHistory[2][MAP_NUM] == mapNum) && mapNum != 0xFF)
+                        break;
+                }
+                sRoamerLocation[MAP_NUM] = mapNum;
+                return;
+            }
+            locSet++;
+        }
+    }
+}
+
+bool8 IsRoamerAt(u8 mapGroup, u8 mapNum)
+{
+    struct Roamer *roamer = &gSaveBlock1Ptr->roamer;
+
+    if (roamer->active && mapGroup == sRoamerLocation[MAP_GRP] && mapNum == sRoamerLocation[MAP_NUM])
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void CreateRoamerMonInstance(void)
+{
+    struct Pokemon *mon;
+    struct Roamer *roamer;
+
+    mon = &gEnemyParty[0];
+    ZeroEnemyPartyMons();
+    roamer = &gSaveBlock1Ptr->roamer;
+    CreateMonWithIVsPersonality(mon, roamer->species, roamer->level, roamer->ivs, roamer->personality);
+    SetMonData(mon, MON_DATA_STATUS, &gSaveBlock1Ptr->roamer.status);
+    SetMonData(mon, MON_DATA_HP, &gSaveBlock1Ptr->roamer.hp);
+    SetMonData(mon, MON_DATA_COOL, &gSaveBlock1Ptr->roamer.cool);
+    SetMonData(mon, MON_DATA_BEAUTY, &gSaveBlock1Ptr->roamer.beauty);
+    SetMonData(mon, MON_DATA_CUTE, &gSaveBlock1Ptr->roamer.cute);
+    SetMonData(mon, MON_DATA_SMART, &gSaveBlock1Ptr->roamer.smart);
+    SetMonData(mon, MON_DATA_TOUGH, &gSaveBlock1Ptr->roamer.tough);
+}
+
+bool8 TryStartRoamerEncounter(void)
+{
+    if (IsRoamerAt(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum) == TRUE && (Random() % 4) == 0)
+    {
+        CreateRoamerMonInstance();
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+void UpdateRoamerHPStatus(struct Pokemon *mon)
+{
+    (&gSaveBlock1Ptr->roamer)->hp = GetMonData(mon, MON_DATA_HP);
+    (&gSaveBlock1Ptr->roamer)->status = GetMonData(mon, MON_DATA_STATUS);
+
+    RoamerMoveToOtherLocationSet();
+}
+
+void SetRoamerInactive(void)
+{
+    struct Roamer *roamer = &gSaveBlock1Ptr->roamer;
+    roamer->active = FALSE;
+}
+
+void GetRoamerLocation(u8 *mapGroup, u8 *mapNum)
+{
+    *mapGroup = sRoamerLocation[MAP_GRP];
+    *mapNum = sRoamerLocation[MAP_NUM];
+}

src/rom4.c

@@ -0,0 +1,19 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+IWRAM_DATA void *gUnknown_03000E0C;
+IWRAM_DATA u8 gUnknown_03000E10[4];
+IWRAM_DATA u8 (*gUnknown_03000E14)(u32);
+IWRAM_DATA u8 gUnknown_03000E18;
+IWRAM_DATA u8 gUnknown_03000E19;
+IWRAM_DATA void *rom4_c_unused_03000e1c;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/safari_zone.c

@@ -60,7 +60,7 @@ void SetSafariZoneFlag(void)
 
 void ResetSafariZoneFlag(void)
 {
-    FlagReset(SYS_SAFARI_MODE);
+    FlagClear(SYS_SAFARI_MODE);
 }
 
 void EnterSafariMode(void)
@@ -114,7 +114,7 @@ void sub_80FC190(void)
     {
         SetMainCallback2(c2_exit_to_overworld_2_switch);
     }
-    else if (gBattleOutcome == 8)
+    else if (gBattleOutcome == BATTLE_SAFARI_OUT_OF_BALLS)
     {
         ScriptContext2_RunNewScript(gUnknown_082A4B4C);
         warp_in();
@@ -139,7 +139,7 @@ static void ClearAllPokeblockFeeders(void)
     memset(sPokeblockFeeders, 0, sizeof(sPokeblockFeeders));
 }
 
-static void GetPokeblockFeederInFront(void)
+void GetPokeblockFeederInFront(void)
 {
     s16 x, y;
     u16 i;

src/save.c

@@ -2,17 +2,19 @@
 #include "gba/flash_internal.h"
 #include "save.h"
 #include "game_stat.h"
+#include "task.h"
 
-extern struct SaveSectionOffsets gSaveSectionOffsets[0xE];
 extern struct SaveSectionLocation gRamSaveSectionLocations[0xE];
 extern u8 gDecompressionBuffer[];
 extern u32 gFlashMemoryPresent;
 extern u16 gUnknown_03006294;
+extern bool8 gSoftResetDisabled;
+
+extern const struct SaveSectionOffsets gSaveSectionOffsets[0xE];
 
 extern void DoSaveFailedScreen(u8); // save_failed_screen
 extern void LoadSerializedGame(void); // load_save
 extern bool32 ProgramFlashSectorAndVerify(u8 sector, u8 *data);
-extern void ReadFlash(u8 sector, u32 arg1, void* data, u32 size);
 
 // iwram common
 u16 gLastWrittenSector;
@@ -576,84 +578,27 @@ u16 CalculateChecksum(void *data, u16 size)
     return ((checksum >> 16) + checksum);
 }
 
-#ifdef NONMATCHING
-// the initial allocation of the pointer and toAdd variable doesnt match up with the original function. however, forcing it is impossible since gRamSaveSectionLocations is loaded first.
 void UpdateSaveAddresses(void)
 {
     int i = 0;
-    gRamSaveSectionLocations[i].data = gSaveBlock2Ptr + gSaveSectionOffsets[0].toAdd;
-    gRamSaveSectionLocations[i].size = gSaveSectionOffsets[0].size;
 
-    for(i = 1; i < 5; i++)
+    gRamSaveSectionLocations[i].data = (void*)(gSaveBlock2Ptr) + gSaveSectionOffsets[i].toAdd;
+    gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
+
+    for (i = 1; i < 5; i++)
     {
-        gRamSaveSectionLocations[i].data = gSaveBlock1Ptr + gSaveSectionOffsets[i].toAdd;
+        gRamSaveSectionLocations[i].data = (void*)(gSaveBlock1Ptr) + gSaveSectionOffsets[i].toAdd;
         gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
     }
 
-    for(i = 5; i < 14; i++)
+    for (i = 5; i < 14; i++)
     {
-        gRamSaveSectionLocations[i].data = gPokemonStoragePtr + gSaveSectionOffsets[i].toAdd;
+        gRamSaveSectionLocations[i].data = (void*)(gPokemonStoragePtr) + gSaveSectionOffsets[i].toAdd;
         gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
+
+        i++;i--; // needed to match
     }
 }
-#else
-__attribute__((naked))
-void UpdateSaveAddresses(void)
-{
-    asm(".syntax unified\n\
-    push {r4,r5,lr}\n\
-    ldr r3, =gRamSaveSectionLocations\n\
-    ldr r0, =gSaveBlock2Ptr\n\
-    ldr r2, =gSaveSectionOffsets\n\
-    ldrh r1, [r2]\n\
-    ldr r0, [r0]\n\
-    adds r0, r1\n\
-    str r0, [r3]\n\
-    ldrh r0, [r2, 0x2]\n\
-    strh r0, [r3, 0x4]\n\
-    ldr r5, =gSaveBlock1Ptr\n\
-    adds r3, 0x8\n\
-    adds r2, 0x4\n\
-    movs r4, 0x3\n\
-_081531AC:\n\
-    ldrh r0, [r2]\n\
-    ldr r1, [r5]\n\
-    adds r1, r0\n\
-    str r1, [r3]\n\
-    ldrh r0, [r2, 0x2]\n\
-    strh r0, [r3, 0x4]\n\
-    adds r3, 0x8\n\
-    adds r2, 0x4\n\
-    subs r4, 0x1\n\
-    cmp r4, 0\n\
-    bge _081531AC\n\
-    movs r4, 0x5\n\
-    ldr r1, =gRamSaveSectionLocations\n\
-    ldr r5, =gPokemonStoragePtr\n\
-    ldr r0, =gSaveSectionOffsets\n\
-    adds r3, r1, 0\n\
-    adds r3, 0x28\n\
-    adds r2, r0, 0\n\
-    adds r2, 0x14\n\
-_081531D2:\n\
-    ldrh r0, [r2]\n\
-    ldr r1, [r5]\n\
-    adds r1, r0\n\
-    str r1, [r3]\n\
-    ldrh r0, [r2, 0x2]\n\
-    strh r0, [r3, 0x4]\n\
-    adds r3, 0x8\n\
-    adds r2, 0x4\n\
-    adds r4, 0x1\n\
-    cmp r4, 0xD\n\
-    ble _081531D2\n\
-    pop {r4,r5}\n\
-    pop {r0}\n\
-    bx r0\n\
-    .pool\n\
-    .syntax divided");
-}
-#endif
 
 extern u32 GetGameStat(u8 index); // rom4
 extern void IncrementGameStat(u8 index); // rom4
@@ -860,7 +805,7 @@ u32 sub_81535DC(u8 sector, u8* dst)
 
     if (sector != 30 && sector != 31)
         return 0xFF;
-    ReadFlash(sector, 0, &gSaveDataBuffer, sizeof(struct SaveSection));
+    ReadFlash(sector, 0, (u8 *)&gSaveDataBuffer, sizeof(struct SaveSection));
     if (*(u32*)(&gSaveDataBuffer.data[0]) != 0xB39D)
         return 0xFF;
     // copies whole save section except u32 counter
@@ -894,3 +839,85 @@ u32 sub_8153634(u8 sector, u8* src)
         return 0xFF;
     return 1;
 }
+
+extern void save_serialize_map(void);
+extern void sub_8076D5C(void);
+extern void sav2_gender2_inplace_and_xFE(void);
+extern void sub_800ADF8(void);
+extern bool8 sub_800A520(void);
+
+void sub_8153688(u8 taskId)
+{
+    s16* taskData = gTasks[taskId].data;
+
+    switch (taskData[0])
+    {
+    case 0:
+        gSoftResetDisabled = TRUE;
+        taskData[0] = 1;
+        break;
+    case 1:
+        sub_800ADF8();
+        taskData[0] = 2;
+        break;
+    case 2:
+        if (sub_800A520())
+        {
+            if (taskData[2] == 0)
+                save_serialize_map();
+            taskData[0] = 3;
+        }
+        break;
+    case 3:
+        if (taskData[2] == 0)
+            sub_8076D5C();
+        sub_8153380();
+        taskData[0] = 4;
+        break;
+    case 4:
+        if (++taskData[1] == 5)
+        {
+            taskData[1] = 0;
+            taskData[0] = 5;
+        }
+        break;
+    case 5:
+        if (sub_81533AC())
+            taskData[0] = 6;
+        else
+            taskData[0] = 4;
+        break;
+    case 6:
+        sub_81533E0();
+        taskData[0] = 7;
+        break;
+    case 7:
+        if (taskData[2] == 0)
+            sav2_gender2_inplace_and_xFE();
+        sub_800ADF8();
+        taskData[0] = 8;
+        break;
+    case 8:
+        if (sub_800A520())
+        {
+            sub_8153408();
+            taskData[0] = 9;
+        }
+        break;
+    case 9:
+        sub_800ADF8();
+        taskData[0] = 10;
+        break;
+    case 10:
+        if (sub_800A520())
+            taskData[0]++;
+        break;
+    case 11:
+        if (++taskData[1] > 5)
+        {
+            gSoftResetDisabled = FALSE;
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}

src/save_failed_screen.c

@@ -0,0 +1,426 @@
+#include "global.h"
+#include "text.h"
+#include "main.h"
+#include "palette.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "task.h"
+#include "window.h"
+#include "menu.h"
+#include "save.h"
+#include "gba/flash_internal.h"
+
+#define MSG_WIN_TOP 12
+#define CLOCK_WIN_TOP (MSG_WIN_TOP - 4)
+
+extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor *color, s8 speed, u8 *str);
+
+extern void (*gGameContinueCallback)(void);
+
+extern u32 gDamagedSaveSectors;
+
+extern const u8 gBirchHelpGfx[];
+extern const u8 gBirchBagTilemap[];
+extern const u8 gBirchGrassTilemap[];
+extern const u16 gBirchBagGrassPal[];
+extern const u16 gUnknown_0850FEFC[];
+extern const u16 gUnknown_0860F074[];
+extern const u32 gUnknown_0850E87C[];
+extern struct SaveSection gSaveDataBuffer;
+
+extern u8 gText_SaveFailedCheckingBackup[];
+extern u8 gText_BackupMemoryDamaged[];
+extern u8 gText_CheckCompleted[];
+extern u8 gText_SaveCompleteGameCannotContinue[];
+extern u8 gText_SaveCompletePressA[];
+extern u8 gText_GamePlayCannotBeContinued[];
+
+extern u8 gDecompressionBuffer[];
+
+// gSaveFailedClockInfo enum
+enum
+{
+    CLOCK_RUNNING,
+    DEBUG_TIMER
+};
+
+// gSaveFailedWindowIds enum
+enum
+{
+    TEXT_WIN_ID,
+    CLOCK_WIN_ID
+};
+
+EWRAM_DATA u16 gSaveFailedType = {0};
+EWRAM_DATA u16 gSaveFailedClockInfo[2] = {0};
+EWRAM_DATA u8 gSaveFailedUnused1[12] = {0};
+EWRAM_DATA u8 gSaveFailedWindowIds[2] = {0};
+EWRAM_DATA u8 gSaveFailedUnused2[4] = {0};
+
+static const struct OamData sClockOamData =
+{
+    160, // Y
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0
+};
+
+static const struct BgTemplate gUnknown_085EFD88[3] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 31,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0,
+    },
+    {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 14,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0,
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 15,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0,
+    },
+};
+
+static const struct WindowTemplate gUnknown_085EFD94[] =
+{
+    {
+        .priority = 255,
+        .tilemapLeft = 0,
+        .tilemapTop = 0,
+        .width = 0,
+        .height = 0,
+        .paletteNum = 0,
+        .baseBlock = 0,
+    }
+};
+
+static const struct WindowTemplate gUnknown_085EFD9C[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 13,
+        .width = 28,
+        .height = 6,
+        .paletteNum = 15,
+        .baseBlock = 1,
+    }
+};
+
+static const struct WindowTemplate gUnknown_085EFDA4[] =
+{
+    {
+        .priority = 0,
+        .tilemapLeft = 14,
+        .tilemapTop = 9,
+        .width = 2,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 169,
+    }
+};
+
+static const u8 sClockFrames[8][3] =
+{
+    { 1, 0, 0 },
+    { 5, 0, 0 },
+    { 9, 0, 0 },
+    { 5, 0, 1 },
+    { 1, 0, 1 },
+    { 5, 1, 1 },
+    { 9, 1, 0 },
+    { 5, 1, 0 },
+};
+
+static const u8 gSaveFailedClockPal[] = INCBIN_U8("graphics/misc/clock_small.gbapal");
+static const u8 gSaveFailedClockGfx[] = INCBIN_U8("graphics/misc/clock_small.4bpp.lz");
+
+static void CB2_SaveFailedScreen(void);
+static void CB2_WipeSave(void);
+static void CB2_GameplayCannotBeContinued(void);
+static void CB2_FadeAndReturnToTitleScreen(void);
+static void CB2_ReturnToTitleScreen(void);
+static void VBlankCB_UpdateClockGraphics(void);
+static bool8 VerifySectorWipe(u16 sector);
+static bool8 WipeSectors(u32);
+
+// although this is a general text printer, it's only used in this file.
+static void SaveFailedScreenTextPrint(u8 *text, u8 var1, u8 var2)
+{
+    struct TextColor color;
+
+    color.fgColor = 0;
+    color.bgColor = 15;
+    color.shadowColor = 3;
+    AddTextPrinterParametrized2(gSaveFailedWindowIds[TEXT_WIN_ID], 1, var1 * 8, var2 * 8 + 1, 0, 0, &color, 0, text);
+}
+
+void DoSaveFailedScreen(u8 saveType)
+{
+    SetMainCallback2(CB2_SaveFailedScreen);
+    gSaveFailedType = saveType;
+    gSaveFailedClockInfo[CLOCK_RUNNING] = FALSE;
+    gSaveFailedClockInfo[DEBUG_TIMER] = 0;
+    gSaveFailedWindowIds[TEXT_WIN_ID] = 0;
+    gSaveFailedWindowIds[CLOCK_WIN_ID] = 0;
+}
+
+static void VBlankCB(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void CB2_SaveFailedScreen(void)
+{
+    switch (gMain.state)
+    {
+        case 0:
+        default:
+            SetVBlankCallback(NULL);
+            SetGpuReg(REG_OFFSET_DISPCNT, 0);
+            SetGpuReg(REG_OFFSET_BG3CNT, 0);
+            SetGpuReg(REG_OFFSET_BG2CNT, 0);
+            SetGpuReg(REG_OFFSET_BG1CNT, 0);
+            SetGpuReg(REG_OFFSET_BG0CNT, 0);
+            SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+            SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+            SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+            // how come this doesnt use the Dma manager?
+            DmaFill16(3, 0, VRAM, VRAM_SIZE);
+            DmaFill32(3, 0, OAM, OAM_SIZE);
+            DmaFill16(3, 0, PLTT, PLTT_SIZE);
+            LZ77UnCompVram(gBirchHelpGfx, (void *)VRAM);
+            LZ77UnCompVram(gBirchBagTilemap, (void *)(VRAM + 0x7000));
+            LZ77UnCompVram(gBirchGrassTilemap, (void *)(VRAM + 0x7800));
+            LZ77UnCompVram(gSaveFailedClockGfx, (void *)(VRAM + 0x10020));
+            ResetBgsAndClearDma3BusyFlags(0);
+            InitBgsFromTemplates(0, gUnknown_085EFD88, 3);
+            SetBgTilemapBuffer(0, (void *)&gDecompressionBuffer[0x2000]);
+            CpuFill32(0, &gDecompressionBuffer[0x2000], 0x800);
+            LoadBgTiles(0, gUnknown_0850E87C, 0x120, 0x214);
+            InitWindows(gUnknown_085EFD94);
+            // AddWindowWithoutTileMap returns a u16/integer, but the info is clobbered into a u8 here resulting in lost info. Bug?
+            gSaveFailedWindowIds[TEXT_WIN_ID] = AddWindowWithoutTileMap(gUnknown_085EFD9C);
+            SetWindowAttribute(gSaveFailedWindowIds[TEXT_WIN_ID], 7, (u32)&gDecompressionBuffer[0x2800]);
+            gSaveFailedWindowIds[CLOCK_WIN_ID] = AddWindowWithoutTileMap(gUnknown_085EFDA4);
+            SetWindowAttribute(gSaveFailedWindowIds[CLOCK_WIN_ID], 7, (u32)&gDecompressionBuffer[0x3D00]);
+            DeactivateAllTextPrinters();
+            ResetSpriteData();
+            ResetTasks();
+            ResetPaletteFade();
+            LoadPalette(gBirchBagGrassPal, 0, 0x40);
+            LoadPalette(gSaveFailedClockPal, 0x100, 0x20);
+            LoadPalette(gUnknown_0850FEFC, 0xE0, 0x20);
+            LoadPalette(gUnknown_0860F074, 0xF0, 0x20);
+            SetWindowBorderStyle(gSaveFailedWindowIds[TEXT_WIN_ID], FALSE, 0x214, 0xE);
+            SetWindowBorderStyle(gSaveFailedWindowIds[CLOCK_WIN_ID], FALSE, 0x214, 0xE);
+            FillWindowPixelBuffer(gSaveFailedWindowIds[CLOCK_WIN_ID], 0x11); // backwards?
+            FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+            CopyWindowToVram(gSaveFailedWindowIds[CLOCK_WIN_ID], 2); // again?
+            CopyWindowToVram(gSaveFailedWindowIds[TEXT_WIN_ID], 1);
+            SaveFailedScreenTextPrint(gText_SaveFailedCheckingBackup, 1, 0);
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0);
+            EnableInterrupts(1);
+            SetVBlankCallback(VBlankCB);
+            SetGpuReg(0, 0x1040);
+            ShowBg(0);
+            ShowBg(2);
+            ShowBg(3);
+            gMain.state++;
+            break;
+        case 1:
+            if (!UpdatePaletteFade())
+            {
+                SetMainCallback2(CB2_WipeSave);
+                SetVBlankCallback(VBlankCB_UpdateClockGraphics);
+            }
+            break;
+    }
+}
+
+static void CB2_WipeSave(void)
+{
+    u8 wipeTries = 0;
+
+    gSaveFailedClockInfo[CLOCK_RUNNING] = TRUE;
+
+    while (gDamagedSaveSectors != 0 && wipeTries < 3)
+    {
+        if (WipeSectors(gDamagedSaveSectors) != FALSE)
+        {
+            FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+            SaveFailedScreenTextPrint(gText_BackupMemoryDamaged, 1, 0);
+            SetMainCallback2(CB2_GameplayCannotBeContinued);
+            return;
+        }
+
+        FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+        SaveFailedScreenTextPrint(gText_CheckCompleted, 1, 0);
+        HandleSavingData(gSaveFailedType);
+
+        if (gDamagedSaveSectors != 0)
+        {
+            FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+            SaveFailedScreenTextPrint(gText_SaveFailedCheckingBackup, 1, 0);
+        }
+
+        wipeTries++;
+    }
+
+    if (wipeTries == 3)
+    {
+        FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+        SaveFailedScreenTextPrint(gText_BackupMemoryDamaged, 1, 0);
+    }
+    else
+    {
+        FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+
+        if (gGameContinueCallback == NULL)
+            SaveFailedScreenTextPrint(gText_SaveCompleteGameCannotContinue, 1, 0);
+        else
+            SaveFailedScreenTextPrint(gText_SaveCompletePressA, 1, 0);
+    }
+
+    SetMainCallback2(CB2_FadeAndReturnToTitleScreen);
+}
+
+static void CB2_GameplayCannotBeContinued(void)
+{
+    gSaveFailedClockInfo[CLOCK_RUNNING] = FALSE;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        FillWindowPixelBuffer(gSaveFailedWindowIds[TEXT_WIN_ID], 0x11);
+        SaveFailedScreenTextPrint(gText_GamePlayCannotBeContinued, 1, 0);
+        SetVBlankCallback(VBlankCB);
+        SetMainCallback2(CB2_FadeAndReturnToTitleScreen);
+    }
+}
+
+static void CB2_FadeAndReturnToTitleScreen(void)
+{
+    gSaveFailedClockInfo[CLOCK_RUNNING] = FALSE;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
+        SetVBlankCallback(VBlankCB);
+        SetMainCallback2(CB2_ReturnToTitleScreen);
+    }
+}
+
+static void CB2_ReturnToTitleScreen(void)
+{
+    if (!UpdatePaletteFade())
+    {
+        if (gGameContinueCallback == NULL) // no callback exists, so do a soft reset.
+        {
+            DoSoftReset();
+        }
+        else
+        {
+            SetMainCallback2((MainCallback)gGameContinueCallback);
+            gGameContinueCallback = NULL;
+        }
+    }
+}
+
+static void VBlankCB_UpdateClockGraphics(void)
+{
+    unsigned int n = (gMain.vblankCounter2 >> 3) & 7;
+
+    gMain.oamBuffer[0] = sClockOamData;
+    gMain.oamBuffer[0].x = 112;
+    gMain.oamBuffer[0].y = (CLOCK_WIN_TOP + 1) * 8;;
+
+    if (gSaveFailedClockInfo[CLOCK_RUNNING] != FALSE)
+    {
+        gMain.oamBuffer[0].tileNum = sClockFrames[n][0];
+        gMain.oamBuffer[0].matrixNum = (sClockFrames[n][2] << 4) | (sClockFrames[n][1] << 3);
+    }
+    else
+    {
+        gMain.oamBuffer[0].tileNum = 1;
+    }
+
+    CpuFastCopy(gMain.oamBuffer, (void *)OAM, 4);
+
+    if (gSaveFailedClockInfo[DEBUG_TIMER])
+        gSaveFailedClockInfo[DEBUG_TIMER]--;
+}
+
+static bool8 VerifySectorWipe(u16 sector)
+{
+    u32 *ptr = (u32 *)&gSaveDataBuffer;
+    u16 i;
+
+    ReadFlash(sector, 0, (u8 *)ptr, 4096);
+
+    for (i = 0; i < 0x400; i++, ptr++)
+        if (*ptr)
+            return TRUE;
+
+    return FALSE;
+}
+
+static bool8 WipeSector(u16 sector)
+{
+    u16 i, j;
+    bool8 failed = TRUE;
+
+    for (i = 0; failed && i < 130; i++)
+    {
+        for (j = 0; j < 0x1000; j++)
+            ProgramFlashByte(sector, j, 0);
+
+        failed = VerifySectorWipe(sector);
+    }
+
+    return failed;
+}
+
+static bool8 WipeSectors(u32 sectorBits)
+{
+    u16 i;
+
+    for (i = 0; i < 0x20; i++)
+        if ((sectorBits & (1 << i)) && !WipeSector(i))
+            sectorBits &= ~(1 << i);
+
+    if (sectorBits == 0)
+        return FALSE;
+    else
+        return TRUE;
+}

src/save_location.c

@@ -0,0 +1,146 @@
+#include "global.h"
+#include "save_location.h"
+#include "map_constants.h"
+
+// used to make the list defines a little less ugly.
+#define MAP(name) ((MAP_GROUP_##name << 8) + (MAP_ID_##name))
+
+// specialSaveWarp flags
+#define POKECENTER_SAVEWARP (1 << 1)
+#define LOBBY_SAVEWARP (1 << 2)
+#define UNK_SPECIAL_SAVE_WARP_FLAG_3 (1 << 3)
+
+static bool32 IsCurMapInLocationList(const u16 *list)
+{
+    u16 locSum = (gSaveBlock1Ptr->location.mapGroup << 8) + (gSaveBlock1Ptr->location.mapNum);
+
+    // im sure it was written a different way, but for the love of christ I cant figure out how to write it different where it still matches.
+    if (*list != 0xFFFF)
+    {
+        u16 termValue = 0xFFFF;
+        const u16 *localList;
+        for (localList = list; *localList != termValue; localList++)
+            if (*localList == locSum)
+                return TRUE;
+    }
+    return FALSE;
+}
+
+// TODO: Not require a packed u16 array for these lists
+static const u16 sSaveLocationPokeCenterList[] =
+{
+    MAP(OLDALE_TOWN_POKEMON_CENTER_1F),
+    MAP(OLDALE_TOWN_POKEMON_CENTER_2F),
+    MAP(DEWFORD_TOWN_POKEMON_CENTER_1F),
+    MAP(DEWFORD_TOWN_POKEMON_CENTER_2F),
+    MAP(LAVARIDGE_TOWN_POKEMON_CENTER_1F),
+    MAP(LAVARIDGE_TOWN_POKEMON_CENTER_2F),
+    MAP(FALLARBOR_TOWN_POKEMON_CENTER_1F),
+    MAP(FALLARBOR_TOWN_POKEMON_CENTER_2F),
+    MAP(VERDANTURF_TOWN_POKEMON_CENTER_1F),
+    MAP(VERDANTURF_TOWN_POKEMON_CENTER_2F),
+    MAP(PACIFIDLOG_TOWN_POKEMON_CENTER_1F),
+    MAP(PACIFIDLOG_TOWN_POKEMON_CENTER_2F),
+    MAP(PETALBURG_CITY_POKEMON_CENTER_1F),
+    MAP(PETALBURG_CITY_POKEMON_CENTER_2F),
+    MAP(SLATEPORT_CITY_POKEMON_CENTER_1F),
+    MAP(SLATEPORT_CITY_POKEMON_CENTER_2F),
+    MAP(MAUVILLE_CITY_POKEMON_CENTER_1F),
+    MAP(MAUVILLE_CITY_POKEMON_CENTER_2F),
+    MAP(RUSTBORO_CITY_POKEMON_CENTER_1F),
+    MAP(RUSTBORO_CITY_POKEMON_CENTER_2F),
+    MAP(FORTREE_CITY_POKEMON_CENTER_1F),
+    MAP(FORTREE_CITY_POKEMON_CENTER_2F),
+    MAP(LILYCOVE_CITY_POKEMON_CENTER_1F),
+    MAP(LILYCOVE_CITY_POKEMON_CENTER_2F),
+    MAP(MOSSDEEP_CITY_POKEMON_CENTER_1F),
+    MAP(MOSSDEEP_CITY_POKEMON_CENTER_2F),
+    MAP(SOOTOPOLIS_CITY_POKEMON_CENTER_1F),
+    MAP(SOOTOPOLIS_CITY_POKEMON_CENTER_2F),
+    MAP(EVER_GRANDE_CITY_POKEMON_CENTER_1F),
+    MAP(EVER_GRANDE_CITY_POKEMON_CENTER_2F),
+    MAP(EVER_GRANDE_CITY_POKEMON_LEAGUE_1F),
+    MAP(EVER_GRANDE_CITY_POKEMON_LEAGUE_2F),
+    MAP(BATTLE_FRONTIER_POKEMON_CENTER_1F),
+    MAP(BATTLE_FRONTIER_POKEMON_CENTER_2F),
+    MAP(SINGLE_BATTLE_COLOSSEUM),
+    MAP(TRADE_CENTER),
+    MAP(RECORD_CORNER),
+    MAP(DOUBLE_BATTLE_COLOSSEUM),
+    0xFFFF,
+};
+
+static bool32 IsCurMapPokeCenter(void)
+{
+    return IsCurMapInLocationList(sSaveLocationPokeCenterList);
+}
+
+static const u16 sSaveLocationReloadLocList[] = // there's only 1 location, and it's presumed its for the save reload feature for battle tower
+{
+    MAP(BATTLE_TOWER_LOBBY),
+    0xFFFF,
+};
+
+static bool32 IsCurMapReloadLocation(void)
+{
+    return IsCurMapInLocationList(sSaveLocationReloadLocList);
+}
+
+// nulled out list. unknown what this would have been
+static const u16 sUnknown_0861440E[] =
+{
+    0xFFFF,
+};
+
+bool32 sub_81AFCEC(void)
+{
+    return IsCurMapInLocationList(sUnknown_0861440E);
+}
+
+static void TrySetPokeCenterWarpStatus(void)
+{
+    if (IsCurMapPokeCenter() == FALSE)
+        gSaveBlock2Ptr->specialSaveWarp &= ~(POKECENTER_SAVEWARP);
+    else
+        gSaveBlock2Ptr->specialSaveWarp |= POKECENTER_SAVEWARP;
+}
+
+static void TrySetReloadWarpStatus(void)
+{
+    if (!IsCurMapReloadLocation())
+        gSaveBlock2Ptr->specialSaveWarp &= ~(LOBBY_SAVEWARP);
+    else
+        gSaveBlock2Ptr->specialSaveWarp |= LOBBY_SAVEWARP;
+}
+
+// this function definitely sets a warp status, but because the list is empty, it's unknown what this does yet.
+static void sub_81AFD5C(void)
+{
+    if (!sub_81AFCEC())
+        gSaveBlock2Ptr->specialSaveWarp &= ~(UNK_SPECIAL_SAVE_WARP_FLAG_3);
+    else
+        gSaveBlock2Ptr->specialSaveWarp |= UNK_SPECIAL_SAVE_WARP_FLAG_3;
+}
+
+void TrySetMapSaveWarpStatus(void)
+{
+    TrySetPokeCenterWarpStatus();
+    TrySetReloadWarpStatus();
+    sub_81AFD5C();
+}
+
+void sub_81AFDA0(void)
+{
+    gSaveBlock2Ptr->field_A8 |= 0x8000;
+    gSaveBlock2Ptr->field_A8 |= 0x1;
+    gSaveBlock2Ptr->field_A8 |= 0x2;
+    gSaveBlock2Ptr->field_A8 |= 0x4;
+    gSaveBlock2Ptr->field_A8 |= 0x10;
+    gSaveBlock2Ptr->field_A8 |= 0x20;
+    gSaveBlock2Ptr->field_A8 |= 0x8;
+}
+
+void sub_81AFDD0(void)
+{
+    gSaveBlock2Ptr->specialSaveWarp |= 0x80;
+}

src/script.c

@@ -134,12 +134,12 @@ const u8 *ScriptPop(struct ScriptContext *ctx)
     return ctx->stack[ctx->stackDepth];
 }
 
-void ScriptJump(struct ScriptContext *ctx, u8 *ptr)
+void ScriptJump(struct ScriptContext *ctx, const u8 *ptr)
 {
     ctx->scriptPtr = ptr;
 }
 
-void ScriptCall(struct ScriptContext *ctx, u8 *ptr)
+void ScriptCall(struct ScriptContext *ctx, const u8 *ptr)
 {
     ScriptPush(ctx, ctx->scriptPtr);
     ctx->scriptPtr = ptr;

src/script_menu.c

@@ -0,0 +1,16 @@
+
+// Includes
+#include "global.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+IWRAM_DATA u8 gUnknown_03001124[6];
+IWRAM_DATA u32 filler_0300112c;
+
+// Static ROM declarations
+
+// .rodata
+
+// .text

src/sprite.c

@@ -594,7 +594,7 @@ u8 CreateSpriteAt(u8 index, const struct SpriteTemplate *template, s16 x, s16 y,
     return index;
 }
 
-u8 CreateSpriteAndAnimate(struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
+u8 CreateSpriteAndAnimate(const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
 {
     u8 i;
 

src/start_menu.c

@@ -170,13 +170,13 @@ extern const u8 gText_BattlePyramidFloor[];
 void DisplayPyramidFloorWindow(void)
 {
     // TODO: fix location
-    if (*(u16*)(&gSaveBlock2Ptr->field_CAA[8]) == 7)
+    if (gSaveBlock2Ptr->field_CAA[4] == 7)
         sBattlePyramidFloorWindowId = AddWindow(&gPyramidFloorWindowTemplate_1);
     else
         sBattlePyramidFloorWindowId = AddWindow(&gPyramidFloorWindowTemplate_2);
     PutWindowTilemap(sBattlePyramidFloorWindowId);
     sub_81973FC(sBattlePyramidFloorWindowId, 0);
-    StringCopy(gStringVar1, gUnknown_08510510[*(u16*)(&gSaveBlock2Ptr->field_CAA[8])]);
+    StringCopy(gStringVar1, gUnknown_08510510[gSaveBlock2Ptr->field_CAA[4]]);
     StringExpandPlaceholders(gStringVar4, gText_BattlePyramidFloor);
     PrintTextOnWindow(sBattlePyramidFloorWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL);
     CopyWindowToVram(sBattlePyramidFloorWindowId, 2);
@@ -207,7 +207,7 @@ static bool32 PrintStartMenuItemsMultistep(s16 *index, u32 n)
 
     do
     {
-        if (sStartMenuItems[sCurrentStartMenuActions[_index]].func == StartMenu_PlayerName)
+        if (sStartMenuItems[sCurrentStartMenuActions[_index]].func.u8_void == StartMenu_PlayerName)
         {
 
         }

src/string_util.c

@@ -625,7 +625,7 @@ u8 *WriteColorChangeControlCode(u8 *dest, u32 colorType, u8 color)
     return dest;
 }
 
-bool32 sub_8009228(u8 *str)
+bool32 IsStringJapanese(u8 *str)
 {
     while (*str != EOS)
     {

src/text.c

@@ -1,9 +1,9 @@
 #include "global.h"
-#include "text.h"
 #include "main.h"
 #include "palette.h"
 #include "string_util.h"
 #include "window.h"
+#include "text.h"
 
 extern void FillBitmapRect4Bit(struct Bitmap *surface, u16 x, u16 y, u16 width, u16 height, u8 fillValue);
 extern void FillWindowPixelRect(u8 windowId, u8 fillValue, u16 x, u16 y, u16 width, u16 height);
@@ -32,11 +32,7 @@ u8 gUnknown_03002FB0[0x20];
 u8 gUnknown_03002FD0[0x20];
 u8 gUnknown_03002FF0[0x20];
 u8 gGlyphDimensions[0x2];
-struct {
-    u8 flag_0:1;
-    u8 flag_1:1;
-    u8 flag_2:1;
-} gTextFlags;
+TextFlags gTextFlags;
 
 const u8 gFontHalfRowOffsets[] = {
 	0x00, 0x01, 0x02, 0x00, 0x03, 0x04, 0x05, 0x03, 0x06, 0x07, 0x08, 0x06, 0x00, 0x01, 0x02, 0x00,
@@ -149,7 +145,7 @@ void DeactivateAllTextPrinters (void)
         gTextPrinters[printer].sub_union.sub.active = 0;
 }
 
-u16 PrintTextOnWindow(u8 windowId, u8 fontId, u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextSubPrinter *, u16))
+u16 PrintTextOnWindow(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextSubPrinter *, u16))
 {
     struct TextSubPrinter subPrinter;
 
@@ -1972,7 +1968,7 @@ bool8 TextPrinterWaitAutoMode(struct TextPrinter *textPrinter)
     }
 }
 
-bool8 TextPrinterWaitWithDownArrow(struct TextPrinter *textPrinter)
+bool16 TextPrinterWaitWithDownArrow(struct TextPrinter *textPrinter)
 {
     bool8 result = FALSE;
     if (gTextFlags.flag_2 != 0)
@@ -1991,9 +1987,9 @@ bool8 TextPrinterWaitWithDownArrow(struct TextPrinter *textPrinter)
     return result;
 }
 
-bool8 TextPrinterWait(struct TextPrinter *textPrinter)
+bool16 TextPrinterWait(struct TextPrinter *textPrinter)
 {
-    bool8 result = FALSE;
+    bool16 result = FALSE;
     if (gTextFlags.flag_2 != 0)
     {
         result = TextPrinterWaitAutoMode(textPrinter);

src/unk_text_util_2.c

@@ -0,0 +1,219 @@
+#include "global.h"
+#include "main.h"
+#include "window.h"
+#include "text.h"
+#include "sound.h"
+
+static const u8 gUnknown_08616124[] = {1, 2, 4};
+static const u16 gFont6BrailleGlyphs[] = INCBIN_U16("data/graphics/fonts/font6.fwjpnfont");
+
+static void DecompressGlyphFont6(u16);
+
+u16 Font6Func(struct TextPrinter *textPrinter)
+{
+    u16 char_;
+    struct TextPrinterSubStruct *sub;
+    
+    sub = &textPrinter->sub_union.sub;
+    switch (textPrinter->state)
+    {
+        case 0:
+            if (gMain.heldKeys & (A_BUTTON | B_BUTTON) && sub->font_type_upper)
+            {
+                textPrinter->delayCounter = 0;
+            }
+            if (textPrinter->delayCounter && textPrinter->text_speed)
+            {
+                textPrinter->delayCounter --;
+                if (gTextFlags.flag_0 && gMain.newKeys & (A_BUTTON | B_BUTTON))
+                {
+                    sub->font_type_upper = TRUE;
+                    textPrinter->delayCounter = 0;
+                }
+                return 3;
+            }
+            if (gTextFlags.flag_2)
+            {
+                textPrinter->delayCounter = 3;
+            }
+            else
+            {
+                textPrinter->delayCounter = textPrinter->text_speed;
+            }
+            char_ = *textPrinter->subPrinter.current_text_offset ++;
+            switch (char_)
+            {
+                case EOS:
+                    return 1;
+                case CHAR_NEWLINE:
+                    textPrinter->subPrinter.currentX = textPrinter->subPrinter.x;
+                    textPrinter->subPrinter.currentY += gFonts[textPrinter->subPrinter.fontId].maxLetterHeight + textPrinter->subPrinter.lineSpacing;
+                    return 2;
+                case PLACEHOLDER_BEGIN:
+                    textPrinter->subPrinter.current_text_offset ++;
+                    return 2;
+                case EXT_CTRL_CODE_BEGIN:
+                    char_ = *textPrinter->subPrinter.current_text_offset ++;
+                    switch (char_)
+                    {
+                        case 1:
+                            textPrinter->subPrinter.fontColor_h = *textPrinter->subPrinter.current_text_offset ++;
+                            GenerateFontHalfRowLookupTable(textPrinter->subPrinter.fontColor_h, textPrinter->subPrinter.bgColor, textPrinter->subPrinter.shadowColor);
+                            return 2;
+                        case 2:
+                            textPrinter->subPrinter.bgColor = *textPrinter->subPrinter.current_text_offset ++;
+                            GenerateFontHalfRowLookupTable(textPrinter->subPrinter.fontColor_h, textPrinter->subPrinter.bgColor, textPrinter->subPrinter.shadowColor);
+                            return 2;
+                        case 3:
+                            textPrinter->subPrinter.shadowColor = *textPrinter->subPrinter.current_text_offset ++;
+                            GenerateFontHalfRowLookupTable(textPrinter->subPrinter.fontColor_h, textPrinter->subPrinter.bgColor, textPrinter->subPrinter.shadowColor);
+                            return 2;
+                        case 4:
+                            textPrinter->subPrinter.fontColor_h = *textPrinter->subPrinter.current_text_offset;
+                            textPrinter->subPrinter.bgColor = *++ textPrinter->subPrinter.current_text_offset;
+                            textPrinter->subPrinter.shadowColor = *++ textPrinter->subPrinter.current_text_offset;
+                            textPrinter->subPrinter.current_text_offset ++;
+
+                            GenerateFontHalfRowLookupTable(textPrinter->subPrinter.fontColor_h, textPrinter->subPrinter.bgColor, textPrinter->subPrinter.shadowColor);
+                            return 2;
+                        case 5:
+                            textPrinter->subPrinter.current_text_offset ++;
+                            return 2;
+                        case 6:
+                            sub->font_type = *textPrinter->subPrinter.current_text_offset;
+                            textPrinter->subPrinter.current_text_offset ++;
+                            return 2;
+                        case 7:
+                            return 2;
+                        case 8:
+                            textPrinter->delayCounter = *textPrinter->subPrinter.current_text_offset ++;
+                            textPrinter->state = 6;
+                            return 2;
+                        case 9:
+                            textPrinter->state = 1;
+                            if (gTextFlags.flag_2)
+                            {
+                                sub->frames_visible_counter = 0;
+                            }
+                            return 3;
+                        case 10:
+                            textPrinter->state = 5;
+                            return 3;
+                        case 11:
+                        case 16:
+                            textPrinter->subPrinter.current_text_offset += 2;
+                            return 2;
+                        case 12:
+                            char_ = *++textPrinter->subPrinter.current_text_offset;
+                            break;
+                        case 13:
+                            textPrinter->subPrinter.currentX = textPrinter->subPrinter.x + *textPrinter->subPrinter.current_text_offset ++;
+                            return 2;
+                        case 14:
+                            textPrinter->subPrinter.currentY = textPrinter->subPrinter.y + *textPrinter->subPrinter.current_text_offset ++;
+                            return 2;
+                        case 15:
+                            FillWindowPixelBuffer(textPrinter->subPrinter.windowId, textPrinter->subPrinter.bgColor | (textPrinter->subPrinter.bgColor << 4));
+                            return 2;
+                    }
+                    break;
+                case CHAR_PROMPT_CLEAR:
+                    textPrinter->state = 2;
+                    TextPrinterInitDownArrowCounters(textPrinter);
+                    return 3;
+                case CHAR_PROMPT_SCROLL:
+                    textPrinter->state = 3;
+                    TextPrinterInitDownArrowCounters(textPrinter);
+                    return 3;
+                case 0xF9:
+                    char_ = *textPrinter->subPrinter.current_text_offset ++ | 0x100;
+                    break;
+                case 0xF8:
+                    textPrinter->subPrinter.current_text_offset ++;
+                    return 0;
+            }
+            DecompressGlyphFont6(char_);
+            CopyGlyphToWindow(textPrinter);
+            textPrinter->subPrinter.currentX += gUnknown_03002F90[0x80] + textPrinter->subPrinter.letterSpacing;
+            return 0;
+        case 1:
+            if (TextPrinterWait(textPrinter))
+            {
+                textPrinter->state = 0;
+            }
+            return 3;
+        case 2:
+            if (TextPrinterWaitWithDownArrow(textPrinter))
+            {
+                FillWindowPixelBuffer(textPrinter->subPrinter.windowId, textPrinter->subPrinter.bgColor | (textPrinter->subPrinter.bgColor << 4));
+                textPrinter->subPrinter.currentX = textPrinter->subPrinter.x;
+                textPrinter->subPrinter.currentY = textPrinter->subPrinter.y;
+                textPrinter->state = 0;
+            }
+            return 3;
+        case 3:
+            if (TextPrinterWaitWithDownArrow(textPrinter))
+            {
+                TextPrinterClearDownArrow(textPrinter);
+                textPrinter->scrollDistance = gFonts[textPrinter->subPrinter.fontId].maxLetterHeight + textPrinter->subPrinter.lineSpacing;
+                textPrinter->subPrinter.currentX = textPrinter->subPrinter.x;
+                textPrinter->state = 4;
+            }
+            return 3;
+        case 4:
+            if (textPrinter->scrollDistance)
+            {
+                if (textPrinter->scrollDistance < gUnknown_08616124[gSaveBlock2Ptr->optionsTextSpeed])
+                {
+                    ScrollWindow(textPrinter->subPrinter.windowId, 0, textPrinter->scrollDistance, textPrinter->subPrinter.bgColor | (textPrinter->subPrinter.bgColor << 4));
+                    textPrinter->scrollDistance = 0;
+                }
+                else
+                {
+                    ScrollWindow(textPrinter->subPrinter.windowId, 0, gUnknown_08616124[gSaveBlock2Ptr->optionsTextSpeed], textPrinter->subPrinter.bgColor | (textPrinter->subPrinter.bgColor << 4));
+                    textPrinter->scrollDistance -= gUnknown_08616124[gSaveBlock2Ptr->optionsTextSpeed];
+                }
+                CopyWindowToVram(textPrinter->subPrinter.windowId, 2);
+            }
+            else
+            {
+                textPrinter->state = 0;
+            }
+            return 3;
+        case 5:
+            if (!IsSEPlaying())
+            {
+                textPrinter->state = 0;
+            }
+            return 3;
+        case 6:
+            if (textPrinter->delayCounter)
+            {
+                textPrinter->delayCounter --;
+            }
+            else
+            {
+                textPrinter->state = 0;
+            }
+            return 3;
+    }
+    return 1;
+}
+
+static void DecompressGlyphFont6(u16 glyph)
+{
+    const u16 *glyphs;
+
+    glyphs = gFont6BrailleGlyphs + 0x100 * (glyph / 8) + 0x10 * (glyph % 8);
+    DecompressGlyphTile(glyphs, (u16 *)gUnknown_03002F90);
+    DecompressGlyphTile(glyphs + 0x8, (u16 *)(gUnknown_03002F90 + 0x20));
+    DecompressGlyphTile(glyphs + 0x80, (u16 *)(gUnknown_03002F90 + 0x40));
+    DecompressGlyphTile(glyphs + 0x88, (u16 *)(gUnknown_03002F90 + 0x60));
+    gUnknown_03002F90[0x80] = 0x10;
+    gUnknown_03002F90[0x81] = 0x10;
+}
+
+u8 GetGlyphWidthFont6(void)
+{
+    return 0x10;
+}

src/util.c

@@ -112,7 +112,7 @@ static const u16 sCrc16Table[] =
     0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78,
 };
 
-const u8 gMiscBlank_Gfx[] = INCBIN_U8("graphics/interface/blank.4bpp"); // unused in Emerald
+const u8 gMiscBlank_Gfx[] = INCBIN_U8("graphics/interface/blank.4bpp");
 
 u8 CreateInvisibleSpriteWithCallback(void (*callback)(struct Sprite *))
 {

src/walda_phrase.c

@@ -0,0 +1,257 @@
+#include "global.h"
+#include "walda_phrase.h"
+#include "string_util.h"
+#include "event_data.h"
+#include "naming_screen.h"
+#include "main.h"
+#include "text.h"
+#include "new_game.h"
+
+extern void (*gFieldCallback)(void);
+
+extern const u8 gText_Peekaboo[];
+
+extern u8 *GetWaldaPhrasePtr(void);
+extern bool32 IsWaldaPhraseEmpty(void);
+extern void sub_80AF168(void);
+extern void c2_exit_to_overworld_2_switch(void);
+extern void SetWaldaPhrase(const u8 *src);
+extern void SetWaldaWallpaperPatternId(u8 patternId);
+extern void SetWaldaWallpaperIconId(u8 iconId);
+extern void SetWaldaWallpaperColors(u16 backgroundColor, u16 foregroundColor);
+extern void SetWaldaWallpaperLockedOrUnlocked(bool32 unlocked);
+
+// this file's functions
+static void CB2_HandleGivenWaldaPhrase(void);
+static u32 GetWaldaPhraseInputCase(u8 *inputPtr);
+static bool32 TryCalculateWallpaper(u16* backgroundClr, u16 *foregroundClr, u8 *iconId, u8 *patternId, u16 trainerId, u8 *phrase);
+static void sub_81D9D5C(u8 *array, u8 *letterTableIds, u32 arg2, u32 arg3, u32 loopCount);
+static u32 sub_81D9DAC(u8 *array, u32 arg1, u32 loopCount);
+static void sub_81D9C90(u8 *array, s32 arg1, s32 arg2);
+static void sub_81D9CDC(u8 *array, u32 loopCount, u8 arg2);
+
+// only consonants are allowed, no vowels, some lowercase letters are missing
+static const u8 sWaldaLettersTable[] =
+{
+    CHAR_B, CHAR_C, CHAR_D, CHAR_F, CHAR_G, CHAR_H, CHAR_J, CHAR_K, CHAR_L, CHAR_M, CHAR_N, CHAR_P, CHAR_Q, CHAR_R, CHAR_S, CHAR_T, CHAR_V, CHAR_W, CHAR_Z,
+    CHAR_b, CHAR_c, CHAR_d, CHAR_f, CHAR_g, CHAR_h, CHAR_j, CHAR_k,         CHAR_m, CHAR_n, CHAR_p, CHAR_q,         CHAR_s
+};
+
+enum
+{
+    PHRASE_GIVEN_NEW,
+    PHRASE_NO_CHANGE,
+    PHRASE_FIRST_ATTEMPT
+};
+
+u16 TryBufferWaldaPhrase(void)
+{
+    if (IsWaldaPhraseEmpty())
+        return FALSE;
+
+    StringCopy(gStringVar1, GetWaldaPhrasePtr());
+    return TRUE;
+}
+
+void DoWaldaNamingScreen(void)
+{
+    StringCopy(gStringVar2, GetWaldaPhrasePtr());
+    DoNamingScreen(NAMING_SCREEN_WALDA, gStringVar2, 0, 0, 0, CB2_HandleGivenWaldaPhrase);
+}
+
+static void CB2_HandleGivenWaldaPhrase(void)
+{
+    gSpecialVar_0x8004 = GetWaldaPhraseInputCase(gStringVar2);
+
+    switch (gSpecialVar_0x8004)
+    {
+    case PHRASE_FIRST_ATTEMPT:
+        if (IsWaldaPhraseEmpty())
+            SetWaldaPhrase(gText_Peekaboo);
+        else
+            gSpecialVar_0x8004 = PHRASE_NO_CHANGE;
+        break;
+    case PHRASE_GIVEN_NEW:
+        SetWaldaPhrase(gStringVar2);
+        break;
+    case PHRASE_NO_CHANGE:
+        break;
+    }
+
+    StringCopy(gStringVar1, GetWaldaPhrasePtr());
+    gFieldCallback = sub_80AF168;
+    SetMainCallback2(c2_exit_to_overworld_2_switch);
+}
+
+static u32 GetWaldaPhraseInputCase(u8 *inputPtr)
+{
+    if (inputPtr[0] == EOS)
+        return PHRASE_FIRST_ATTEMPT;
+    if (StringCompare(inputPtr, GetWaldaPhrasePtr()) == 0)
+        return PHRASE_NO_CHANGE;
+
+    return PHRASE_GIVEN_NEW;
+}
+
+u16 TryGetWallpaperWithWaldaPhrase(void)
+{
+    u16 backgroundClr, foregroundClr;
+    u8 patternId, iconId;
+    u16 trainerId = ReadUnalignedWord(gSaveBlock2Ptr->playerTrainerId);
+    gScriptResult = TryCalculateWallpaper(&backgroundClr, &foregroundClr, &iconId, &patternId, trainerId, GetWaldaPhrasePtr());
+
+    if (gScriptResult)
+    {
+        SetWaldaWallpaperPatternId(patternId);
+        SetWaldaWallpaperIconId(iconId);
+        SetWaldaWallpaperColors(backgroundClr, foregroundClr);
+    }
+
+    SetWaldaWallpaperLockedOrUnlocked(gScriptResult);
+    return (bool8)(gScriptResult);
+}
+
+static u8 GetLetterTableId(u8 letter)
+{
+    s32 i;
+
+    for (i = 0; i < ARRAY_COUNT(sWaldaLettersTable); i++)
+    {
+        if (sWaldaLettersTable[i] == letter)
+            return i;
+    }
+
+    return ARRAY_COUNT(sWaldaLettersTable);
+}
+
+static bool32 TryCalculateWallpaper(u16* backgroundClr, u16 *foregroundClr, u8 *iconId, u8 *patternId, u16 trainerId, u8 *phrase)
+{
+    s32 i;
+    ALIGNED(2) u8 array[12];
+    u8 charsByTableId[16];
+    u16 *ptr;
+
+    if (StringLength(phrase) != 15)
+        return FALSE;
+
+    for (i = 0; i < 15; i++)
+    {
+        charsByTableId[i] = GetLetterTableId(phrase[i]);
+        if (charsByTableId[i] == ARRAY_COUNT(sWaldaLettersTable))
+            return FALSE;
+    }
+
+    for (i = 0; i < 14; i++)
+    {
+        sub_81D9D5C(array, charsByTableId, (5 * i), 3 + (8 * i), 5);
+    }
+
+    sub_81D9D5C(array, charsByTableId, 70, 115, 2);
+
+    if (sub_81D9DAC(array, 0, 3) != sub_81D9DAC(charsByTableId, 117, 3))
+        return FALSE;
+
+    sub_81D9C90(array, 9, 21);
+    sub_81D9C90(array, 8, array[8] & 0xF);
+    sub_81D9CDC(array, 8, array[8] >> 4);
+
+    if (array[6] != (array[0] ^ array[2] ^ array[4] ^ (trainerId >> 8)))
+        return FALSE;
+
+    if (array[7] != (array[1] ^ array[3] ^ array[5] ^ (trainerId & 0xFF)))
+        return FALSE;
+
+    ptr = (u16*)(&array[0]);
+    *backgroundClr = *ptr;
+
+    ptr = (u16*)(&array[2]);
+    *foregroundClr = *ptr;
+
+    *iconId = array[4];
+    *patternId = array[5];
+
+    return TRUE;
+}
+
+static void sub_81D9C90(u8 *array, s32 arg1, s32 arg2)
+{
+    s32 i, j;
+    u8 var1, var2;
+
+    for (i = arg2 - 1; i != -1; i--)
+    {
+        var1 = (array[0] & 0x80) >> 7;
+
+        var1++; var1--; // needed to match
+
+        for (j = arg1 - 1; j >= 0; j--)
+        {
+            var2 = array[j] & 0x80;
+            array[j] <<= 1;
+            array[j] |= var1;
+            var1 = var2 >> 7;
+        }
+    }
+}
+
+static void sub_81D9CDC(u8 *array, u32 loopCount, u8 arg2)
+{
+    u32 i;
+
+    arg2 |= (arg2 << 4);
+
+    for (i = 0; i < loopCount; i++)
+    {
+        array[i] ^= arg2;
+    }
+}
+
+static bool8 sub_81D9D0C(u8 *array, u32 arg1)
+{
+    u32 arrayId = arg1 >> 3;
+    u32 bits = 0x80 >> (7 & arg1);
+
+    return ((array[arrayId] & bits) != 0);
+}
+
+static void sub_81D9D28(u8 *array, u32 arg1)
+{
+    u32 arrayId = arg1 >> 3;
+    u8 bits = 0x80 >> (7 & arg1);
+
+    array[arrayId] |= bits;
+}
+
+static void sub_81D9D40(u8 *array, u32 arg1)
+{
+    u32 arrayId = arg1 >> 3;
+    u8 bits = ~(0x80 >> (7 & arg1));
+
+    array[arrayId] &= bits;
+}
+
+static void sub_81D9D5C(u8 *array, u8 *letterTableIds, u32 arg2, u32 arg3, u32 loopCount)
+{
+    u32 i;
+
+    for (i = 0; i < loopCount; i++)
+    {
+        if (sub_81D9D0C(letterTableIds, arg3 + i))
+            sub_81D9D28(array, arg2 + i);
+        else
+            sub_81D9D40(array, arg2 + i);
+    }
+}
+
+static u32 sub_81D9DAC(u8 *array, u32 arg1, u32 loopCount)
+{
+    u32 ret, i;
+
+    for (ret = 0, i = 0; i < loopCount; i++)
+    {
+        ret <<= 1;
+        ret |= sub_81D9D0C(array, arg1 + i);
+    }
+
+    return ret;
+}

src/window.c

@@ -190,7 +190,7 @@ u16 AddWindow(const struct WindowTemplate *template)
     return win;
 }
 
-int AddWindowWithoutTileMap(struct WindowTemplate *template)
+int AddWindowWithoutTileMap(const struct WindowTemplate *template)
 {
     u16 win;
     u8 bgLayer;
@@ -451,7 +451,7 @@ void FillWindowPixelRect(u8 windowId, u8 fillValue, u16 x, u16 y, u16 width, u16
     FillBitmapRect4Bit(&pixelRect, x, y, width, height, fillValue);
 }
 
-void CopyToWindowPixelBuffer(u8 windowId, u8 *src, u16 size, u16 tileOffset)
+void CopyToWindowPixelBuffer(u8 windowId, const u8 *src, u16 size, u16 tileOffset)
 {
     if (size != 0)
         CpuCopy16(src, gWindows[windowId].tileData + (0x20 * tileOffset), size);