summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/data/pokemon/egg_moves.h1310
-rw-r--r--src/daycare.c1353
-rw-r--r--src/menu2.c26
-rw-r--r--src/oak_speech.c6
-rw-r--r--src/pokemon.c14
-rw-r--r--src/quest_log.c10
-rw-r--r--src/text.c12
-rw-r--r--src/text_printer.c14
-rw-r--r--src/tm_case.c2
9 files changed, 2705 insertions, 42 deletions
diff --git a/src/data/pokemon/egg_moves.h b/src/data/pokemon/egg_moves.h
new file mode 100644
index 000000000..f8c250c6d
--- /dev/null
+++ b/src/data/pokemon/egg_moves.h
@@ -0,0 +1,1310 @@
+#define EGG_MOVES_SPECIES_OFFSET 20000
+#define EGG_MOVES_TERMINATOR 0xFFFF
+#define egg_moves(species, moves...) (SPECIES_##species + EGG_MOVES_SPECIES_OFFSET), moves
+
+const u16 gEggMoves[] = {
+ egg_moves(BULBASAUR,
+ MOVE_LIGHT_SCREEN,
+ MOVE_SKULL_BASH,
+ MOVE_SAFEGUARD,
+ MOVE_CHARM,
+ MOVE_PETAL_DANCE,
+ MOVE_MAGICAL_LEAF,
+ MOVE_GRASS_WHISTLE,
+ MOVE_CURSE),
+
+ egg_moves(CHARMANDER,
+ MOVE_BELLY_DRUM,
+ MOVE_ANCIENT_POWER,
+ MOVE_ROCK_SLIDE,
+ MOVE_BITE,
+ MOVE_OUTRAGE,
+ MOVE_BEAT_UP,
+ MOVE_SWORDS_DANCE,
+ MOVE_DRAGON_DANCE),
+
+ egg_moves(SQUIRTLE,
+ MOVE_MIRROR_COAT,
+ MOVE_HAZE,
+ MOVE_MIST,
+ MOVE_FORESIGHT,
+ MOVE_FLAIL,
+ MOVE_REFRESH,
+ MOVE_MUD_SPORT,
+ MOVE_YAWN),
+
+ egg_moves(PIDGEY,
+ MOVE_PURSUIT,
+ MOVE_FAINT_ATTACK,
+ MOVE_FORESIGHT,
+ MOVE_STEEL_WING,
+ MOVE_AIR_CUTTER),
+
+ egg_moves(RATTATA,
+ MOVE_SCREECH,
+ MOVE_FLAME_WHEEL,
+ MOVE_FURY_SWIPES,
+ MOVE_BITE,
+ MOVE_COUNTER,
+ MOVE_REVERSAL,
+ MOVE_UPROAR,
+ MOVE_SWAGGER),
+
+ egg_moves(SPEAROW,
+ MOVE_FAINT_ATTACK,
+ MOVE_FALSE_SWIPE,
+ MOVE_SCARY_FACE,
+ MOVE_QUICK_ATTACK,
+ MOVE_TRI_ATTACK,
+ MOVE_ASTONISH,
+ MOVE_SKY_ATTACK),
+
+ egg_moves(EKANS,
+ MOVE_PURSUIT,
+ MOVE_SLAM,
+ MOVE_SPITE,
+ MOVE_BEAT_UP,
+ MOVE_POISON_FANG),
+
+ egg_moves(SANDSHREW,
+ MOVE_FLAIL,
+ MOVE_SAFEGUARD,
+ MOVE_COUNTER,
+ MOVE_RAPID_SPIN,
+ MOVE_ROCK_SLIDE,
+ MOVE_METAL_CLAW,
+ MOVE_SWORDS_DANCE,
+ MOVE_CRUSH_CLAW),
+
+ egg_moves(NIDORAN_F,
+ MOVE_SUPERSONIC,
+ MOVE_DISABLE,
+ MOVE_TAKE_DOWN,
+ MOVE_FOCUS_ENERGY,
+ MOVE_CHARM,
+ MOVE_COUNTER,
+ MOVE_BEAT_UP),
+
+ egg_moves(NIDORAN_M,
+ MOVE_COUNTER,
+ MOVE_DISABLE,
+ MOVE_SUPERSONIC,
+ MOVE_TAKE_DOWN,
+ MOVE_AMNESIA,
+ MOVE_CONFUSION,
+ MOVE_BEAT_UP),
+
+ egg_moves(VULPIX,
+ MOVE_FAINT_ATTACK,
+ MOVE_HYPNOSIS,
+ MOVE_FLAIL,
+ MOVE_SPITE,
+ MOVE_DISABLE,
+ MOVE_HOWL,
+ MOVE_PSYCH_UP,
+ MOVE_HEAT_WAVE),
+
+ egg_moves(ZUBAT,
+ MOVE_QUICK_ATTACK,
+ MOVE_PURSUIT,
+ MOVE_FAINT_ATTACK,
+ MOVE_GUST,
+ MOVE_WHIRLWIND,
+ MOVE_CURSE),
+
+ egg_moves(ODDISH,
+ MOVE_SWORDS_DANCE,
+ MOVE_RAZOR_LEAF,
+ MOVE_FLAIL,
+ MOVE_SYNTHESIS,
+ MOVE_CHARM,
+ MOVE_INGRAIN),
+
+ egg_moves(PARAS,
+ MOVE_FALSE_SWIPE,
+ MOVE_SCREECH,
+ MOVE_COUNTER,
+ MOVE_PSYBEAM,
+ MOVE_FLAIL,
+ MOVE_SWEET_SCENT,
+ MOVE_LIGHT_SCREEN,
+ MOVE_PURSUIT),
+
+ egg_moves(VENONAT,
+ MOVE_BATON_PASS,
+ MOVE_SCREECH,
+ MOVE_GIGA_DRAIN,
+ MOVE_SIGNAL_BEAM),
+
+ egg_moves(DIGLETT,
+ MOVE_FAINT_ATTACK,
+ MOVE_SCREECH,
+ MOVE_ANCIENT_POWER,
+ MOVE_PURSUIT,
+ MOVE_BEAT_UP,
+ MOVE_UPROAR,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(MEOWTH,
+ MOVE_SPITE,
+ MOVE_CHARM,
+ MOVE_HYPNOSIS,
+ MOVE_AMNESIA,
+ MOVE_PSYCH_UP,
+ MOVE_ASSIST),
+
+ egg_moves(PSYDUCK,
+ MOVE_HYPNOSIS,
+ MOVE_PSYBEAM,
+ MOVE_FORESIGHT,
+ MOVE_LIGHT_SCREEN,
+ MOVE_FUTURE_SIGHT,
+ MOVE_PSYCHIC,
+ MOVE_CROSS_CHOP,
+ MOVE_REFRESH),
+
+ egg_moves(MANKEY,
+ MOVE_ROCK_SLIDE,
+ MOVE_FORESIGHT,
+ MOVE_MEDITATE,
+ MOVE_COUNTER,
+ MOVE_REVERSAL,
+ MOVE_BEAT_UP,
+ MOVE_REVENGE,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(GROWLITHE,
+ MOVE_BODY_SLAM,
+ MOVE_SAFEGUARD,
+ MOVE_CRUNCH,
+ MOVE_THRASH,
+ MOVE_FIRE_SPIN,
+ MOVE_HOWL,
+ MOVE_HEAT_WAVE),
+
+ egg_moves(POLIWAG,
+ MOVE_MIST,
+ MOVE_SPLASH,
+ MOVE_BUBBLE_BEAM,
+ MOVE_HAZE,
+ MOVE_MIND_READER,
+ MOVE_WATER_SPORT,
+ MOVE_ICE_BALL),
+
+ egg_moves(ABRA,
+ MOVE_ENCORE,
+ MOVE_BARRIER,
+ MOVE_KNOCK_OFF,
+ MOVE_FIRE_PUNCH,
+ MOVE_THUNDER_PUNCH,
+ MOVE_ICE_PUNCH),
+
+ egg_moves(MACHOP,
+ MOVE_LIGHT_SCREEN,
+ MOVE_MEDITATE,
+ MOVE_ROLLING_KICK,
+ MOVE_ENCORE,
+ MOVE_SMELLING_SALT,
+ MOVE_COUNTER,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(BELLSPROUT,
+ MOVE_SWORDS_DANCE,
+ MOVE_ENCORE,
+ MOVE_REFLECT,
+ MOVE_SYNTHESIS,
+ MOVE_LEECH_LIFE,
+ MOVE_INGRAIN,
+ MOVE_MAGICAL_LEAF),
+
+ egg_moves(TENTACOOL,
+ MOVE_AURORA_BEAM,
+ MOVE_MIRROR_COAT,
+ MOVE_RAPID_SPIN,
+ MOVE_HAZE,
+ MOVE_SAFEGUARD,
+ MOVE_CONFUSE_RAY),
+
+ egg_moves(GEODUDE,
+ MOVE_MEGA_PUNCH,
+ MOVE_ROCK_SLIDE,
+ MOVE_BLOCK),
+
+ egg_moves(PONYTA,
+ MOVE_FLAME_WHEEL,
+ MOVE_THRASH,
+ MOVE_DOUBLE_KICK,
+ MOVE_HYPNOSIS,
+ MOVE_CHARM,
+ MOVE_DOUBLE_EDGE),
+
+ egg_moves(SLOWPOKE,
+ MOVE_SAFEGUARD,
+ MOVE_BELLY_DRUM,
+ MOVE_FUTURE_SIGHT,
+ MOVE_STOMP,
+ MOVE_MUD_SPORT,
+ MOVE_SLEEP_TALK,
+ MOVE_SNORE),
+
+ egg_moves(FARFETCHD,
+ MOVE_STEEL_WING,
+ MOVE_FORESIGHT,
+ MOVE_MIRROR_MOVE,
+ MOVE_GUST,
+ MOVE_QUICK_ATTACK,
+ MOVE_FLAIL,
+ MOVE_FEATHER_DANCE,
+ MOVE_CURSE),
+
+ egg_moves(DODUO,
+ MOVE_QUICK_ATTACK,
+ MOVE_SUPERSONIC,
+ MOVE_HAZE,
+ MOVE_FAINT_ATTACK,
+ MOVE_FLAIL,
+ MOVE_ENDEAVOR),
+
+ egg_moves(SEEL,
+ MOVE_LICK,
+ MOVE_PERISH_SONG,
+ MOVE_DISABLE,
+ MOVE_HORN_DRILL,
+ MOVE_SLAM,
+ MOVE_ENCORE,
+ MOVE_FAKE_OUT,
+ MOVE_ICICLE_SPEAR),
+
+ egg_moves(GRIMER,
+ MOVE_HAZE,
+ MOVE_MEAN_LOOK,
+ MOVE_LICK,
+ MOVE_IMPRISON,
+ MOVE_CURSE,
+ MOVE_SHADOW_PUNCH,
+ MOVE_EXPLOSION),
+
+ egg_moves(SHELLDER,
+ MOVE_BUBBLE_BEAM,
+ MOVE_TAKE_DOWN,
+ MOVE_BARRIER,
+ MOVE_RAPID_SPIN,
+ MOVE_SCREECH,
+ MOVE_ICICLE_SPEAR),
+
+ egg_moves(GASTLY,
+ MOVE_PSYWAVE,
+ MOVE_PERISH_SONG,
+ MOVE_HAZE,
+ MOVE_ASTONISH,
+ MOVE_WILL_O_WISP,
+ MOVE_GRUDGE,
+ MOVE_EXPLOSION),
+
+ egg_moves(ONIX,
+ MOVE_ROCK_SLIDE,
+ MOVE_FLAIL,
+ MOVE_EXPLOSION,
+ MOVE_BLOCK),
+
+ egg_moves(DROWZEE,
+ MOVE_BARRIER,
+ MOVE_ASSIST,
+ MOVE_ROLE_PLAY,
+ MOVE_FIRE_PUNCH,
+ MOVE_THUNDER_PUNCH,
+ MOVE_ICE_PUNCH),
+
+ egg_moves(KRABBY,
+ MOVE_DIG,
+ MOVE_HAZE,
+ MOVE_AMNESIA,
+ MOVE_FLAIL,
+ MOVE_SLAM,
+ MOVE_KNOCK_OFF,
+ MOVE_SWORDS_DANCE),
+
+ egg_moves(EXEGGCUTE,
+ MOVE_SYNTHESIS,
+ MOVE_MOONLIGHT,
+ MOVE_REFLECT,
+ MOVE_ANCIENT_POWER,
+ MOVE_PSYCH_UP,
+ MOVE_INGRAIN,
+ MOVE_CURSE),
+
+ egg_moves(CUBONE,
+ MOVE_ROCK_SLIDE,
+ MOVE_ANCIENT_POWER,
+ MOVE_BELLY_DRUM,
+ MOVE_SCREECH,
+ MOVE_SKULL_BASH,
+ MOVE_PERISH_SONG,
+ MOVE_SWORDS_DANCE),
+
+ egg_moves(LICKITUNG,
+ MOVE_BELLY_DRUM,
+ MOVE_MAGNITUDE,
+ MOVE_BODY_SLAM,
+ MOVE_CURSE,
+ MOVE_SMELLING_SALT,
+ MOVE_SLEEP_TALK,
+ MOVE_SNORE,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(KOFFING,
+ MOVE_SCREECH,
+ MOVE_PSYWAVE,
+ MOVE_PSYBEAM,
+ MOVE_DESTINY_BOND,
+ MOVE_PAIN_SPLIT,
+ MOVE_WILL_O_WISP),
+
+ egg_moves(RHYHORN,
+ MOVE_CRUNCH,
+ MOVE_REVERSAL,
+ MOVE_ROCK_SLIDE,
+ MOVE_COUNTER,
+ MOVE_MAGNITUDE,
+ MOVE_SWORDS_DANCE,
+ MOVE_CURSE,
+ MOVE_CRUSH_CLAW),
+
+ egg_moves(CHANSEY,
+ MOVE_PRESENT,
+ MOVE_METRONOME,
+ MOVE_HEAL_BELL,
+ MOVE_AROMATHERAPY,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(TANGELA,
+ MOVE_FLAIL,
+ MOVE_CONFUSION,
+ MOVE_MEGA_DRAIN,
+ MOVE_REFLECT,
+ MOVE_AMNESIA,
+ MOVE_LEECH_SEED,
+ MOVE_NATURE_POWER),
+
+ egg_moves(KANGASKHAN,
+ MOVE_STOMP,
+ MOVE_FORESIGHT,
+ MOVE_FOCUS_ENERGY,
+ MOVE_SAFEGUARD,
+ MOVE_DISABLE,
+ MOVE_COUNTER,
+ MOVE_CRUSH_CLAW,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(HORSEA,
+ MOVE_FLAIL,
+ MOVE_AURORA_BEAM,
+ MOVE_OCTAZOOKA,
+ MOVE_DISABLE,
+ MOVE_SPLASH,
+ MOVE_DRAGON_RAGE,
+ MOVE_DRAGON_BREATH),
+
+ egg_moves(GOLDEEN,
+ MOVE_PSYBEAM,
+ MOVE_HAZE,
+ MOVE_HYDRO_PUMP,
+ MOVE_SLEEP_TALK,
+ MOVE_MUD_SPORT),
+
+ egg_moves(MR_MIME,
+ MOVE_FUTURE_SIGHT,
+ MOVE_HYPNOSIS,
+ MOVE_MIMIC,
+ MOVE_PSYCH_UP,
+ MOVE_FAKE_OUT,
+ MOVE_TRICK),
+
+ egg_moves(SCYTHER,
+ MOVE_COUNTER,
+ MOVE_SAFEGUARD,
+ MOVE_BATON_PASS,
+ MOVE_RAZOR_WIND,
+ MOVE_REVERSAL,
+ MOVE_LIGHT_SCREEN,
+ MOVE_ENDURE,
+ MOVE_SILVER_WIND),
+
+ egg_moves(PINSIR,
+ MOVE_FURY_ATTACK,
+ MOVE_FLAIL,
+ MOVE_FALSE_SWIPE,
+ MOVE_FAINT_ATTACK),
+
+ egg_moves(LAPRAS,
+ MOVE_FORESIGHT,
+ MOVE_SUBSTITUTE,
+ MOVE_TICKLE,
+ MOVE_REFRESH,
+ MOVE_DRAGON_DANCE,
+ MOVE_CURSE,
+ MOVE_SLEEP_TALK,
+ MOVE_HORN_DRILL),
+
+ egg_moves(EEVEE,
+ MOVE_CHARM,
+ MOVE_FLAIL,
+ MOVE_ENDURE,
+ MOVE_CURSE,
+ MOVE_TICKLE,
+ MOVE_WISH),
+
+ egg_moves(OMANYTE,
+ MOVE_BUBBLE_BEAM,
+ MOVE_AURORA_BEAM,
+ MOVE_SLAM,
+ MOVE_SUPERSONIC,
+ MOVE_HAZE,
+ MOVE_ROCK_SLIDE,
+ MOVE_SPIKES),
+
+ egg_moves(KABUTO,
+ MOVE_BUBBLE_BEAM,
+ MOVE_AURORA_BEAM,
+ MOVE_RAPID_SPIN,
+ MOVE_DIG,
+ MOVE_FLAIL,
+ MOVE_KNOCK_OFF,
+ MOVE_CONFUSE_RAY),
+
+ egg_moves(AERODACTYL,
+ MOVE_WHIRLWIND,
+ MOVE_PURSUIT,
+ MOVE_FORESIGHT,
+ MOVE_STEEL_WING,
+ MOVE_DRAGON_BREATH,
+ MOVE_CURSE),
+
+ egg_moves(SNORLAX,
+ MOVE_LICK,
+ MOVE_CHARM,
+ MOVE_DOUBLE_EDGE,
+ MOVE_CURSE,
+ MOVE_FISSURE,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(DRATINI,
+ MOVE_LIGHT_SCREEN,
+ MOVE_MIST,
+ MOVE_HAZE,
+ MOVE_SUPERSONIC,
+ MOVE_DRAGON_BREATH,
+ MOVE_DRAGON_DANCE),
+
+ egg_moves(CHIKORITA,
+ MOVE_VINE_WHIP,
+ MOVE_LEECH_SEED,
+ MOVE_COUNTER,
+ MOVE_ANCIENT_POWER,
+ MOVE_FLAIL,
+ MOVE_NATURE_POWER,
+ MOVE_INGRAIN,
+ MOVE_GRASS_WHISTLE),
+
+ egg_moves(CYNDAQUIL,
+ MOVE_FURY_SWIPES,
+ MOVE_QUICK_ATTACK,
+ MOVE_REVERSAL,
+ MOVE_THRASH,
+ MOVE_FORESIGHT,
+ MOVE_COVET,
+ MOVE_HOWL,
+ MOVE_CRUSH_CLAW),
+
+ egg_moves(TOTODILE,
+ MOVE_CRUNCH,
+ MOVE_THRASH,
+ MOVE_HYDRO_PUMP,
+ MOVE_ANCIENT_POWER,
+ MOVE_ROCK_SLIDE,
+ MOVE_MUD_SPORT,
+ MOVE_WATER_SPORT,
+ MOVE_DRAGON_CLAW),
+
+ egg_moves(SENTRET,
+ MOVE_DOUBLE_EDGE,
+ MOVE_PURSUIT,
+ MOVE_SLASH,
+ MOVE_FOCUS_ENERGY,
+ MOVE_REVERSAL,
+ MOVE_SUBSTITUTE,
+ MOVE_TRICK,
+ MOVE_ASSIST),
+
+ egg_moves(HOOTHOOT,
+ MOVE_MIRROR_MOVE,
+ MOVE_SUPERSONIC,
+ MOVE_FAINT_ATTACK,
+ MOVE_WING_ATTACK,
+ MOVE_WHIRLWIND,
+ MOVE_SKY_ATTACK,
+ MOVE_FEATHER_DANCE),
+
+ egg_moves(LEDYBA,
+ MOVE_PSYBEAM,
+ MOVE_BIDE,
+ MOVE_SILVER_WIND),
+
+ egg_moves(SPINARAK,
+ MOVE_PSYBEAM,
+ MOVE_DISABLE,
+ MOVE_SONIC_BOOM,
+ MOVE_BATON_PASS,
+ MOVE_PURSUIT,
+ MOVE_SIGNAL_BEAM),
+
+ egg_moves(CHINCHOU,
+ MOVE_FLAIL,
+ MOVE_SCREECH,
+ MOVE_AMNESIA),
+
+ egg_moves(PICHU,
+ MOVE_REVERSAL,
+ MOVE_BIDE,
+ MOVE_PRESENT,
+ MOVE_ENCORE,
+ MOVE_DOUBLE_SLAP,
+ MOVE_WISH,
+ MOVE_CHARGE),
+
+ egg_moves(CLEFFA,
+ MOVE_PRESENT,
+ MOVE_METRONOME,
+ MOVE_AMNESIA,
+ MOVE_BELLY_DRUM,
+ MOVE_SPLASH,
+ MOVE_MIMIC,
+ MOVE_WISH,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(IGGLYBUFF,
+ MOVE_PERISH_SONG,
+ MOVE_PRESENT,
+ MOVE_FAINT_ATTACK,
+ MOVE_WISH,
+ MOVE_FAKE_TEARS),
+
+ egg_moves(TOGEPI,
+ MOVE_PRESENT,
+ MOVE_MIRROR_MOVE,
+ MOVE_PECK,
+ MOVE_FORESIGHT,
+ MOVE_FUTURE_SIGHT,
+ MOVE_SUBSTITUTE,
+ MOVE_PSYCH_UP),
+
+ egg_moves(NATU,
+ MOVE_HAZE,
+ MOVE_DRILL_PECK,
+ MOVE_QUICK_ATTACK,
+ MOVE_FAINT_ATTACK,
+ MOVE_STEEL_WING,
+ MOVE_PSYCH_UP,
+ MOVE_FEATHER_DANCE,
+ MOVE_REFRESH),
+
+ egg_moves(MAREEP,
+ MOVE_TAKE_DOWN,
+ MOVE_BODY_SLAM,
+ MOVE_SAFEGUARD,
+ MOVE_SCREECH,
+ MOVE_REFLECT,
+ MOVE_ODOR_SLEUTH,
+ MOVE_CHARGE),
+
+ egg_moves(MARILL,
+ MOVE_LIGHT_SCREEN,
+ MOVE_PRESENT,
+ MOVE_AMNESIA,
+ MOVE_FUTURE_SIGHT,
+ MOVE_BELLY_DRUM,
+ MOVE_PERISH_SONG,
+ MOVE_SUPERSONIC,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(SUDOWOODO,
+ MOVE_SELF_DESTRUCT),
+
+ egg_moves(HOPPIP,
+ MOVE_CONFUSION,
+ MOVE_ENCORE,
+ MOVE_DOUBLE_EDGE,
+ MOVE_REFLECT,
+ MOVE_AMNESIA,
+ MOVE_HELPING_HAND,
+ MOVE_PSYCH_UP),
+
+ egg_moves(AIPOM,
+ MOVE_COUNTER,
+ MOVE_SCREECH,
+ MOVE_PURSUIT,
+ MOVE_AGILITY,
+ MOVE_SPITE,
+ MOVE_SLAM,
+ MOVE_DOUBLE_SLAP,
+ MOVE_BEAT_UP),
+
+ egg_moves(SUNKERN,
+ MOVE_GRASS_WHISTLE,
+ MOVE_ENCORE,
+ MOVE_LEECH_SEED,
+ MOVE_NATURE_POWER,
+ MOVE_CURSE,
+ MOVE_HELPING_HAND),
+
+ egg_moves(YANMA,
+ MOVE_WHIRLWIND,
+ MOVE_REVERSAL,
+ MOVE_LEECH_LIFE,
+ MOVE_SIGNAL_BEAM,
+ MOVE_SILVER_WIND),
+
+ egg_moves(WOOPER,
+ MOVE_BODY_SLAM,
+ MOVE_ANCIENT_POWER,
+ MOVE_SAFEGUARD,
+ MOVE_CURSE,
+ MOVE_MUD_SPORT,
+ MOVE_STOCKPILE,
+ MOVE_SWALLOW,
+ MOVE_SPIT_UP),
+
+ egg_moves(MURKROW,
+ MOVE_WHIRLWIND,
+ MOVE_DRILL_PECK,
+ MOVE_MIRROR_MOVE,
+ MOVE_WING_ATTACK,
+ MOVE_SKY_ATTACK,
+ MOVE_CONFUSE_RAY,
+ MOVE_FEATHER_DANCE,
+ MOVE_PERISH_SONG),
+
+ egg_moves(MISDREAVUS,
+ MOVE_SCREECH,
+ MOVE_DESTINY_BOND,
+ MOVE_PSYCH_UP,
+ MOVE_IMPRISON),
+
+ egg_moves(GIRAFARIG,
+ MOVE_TAKE_DOWN,
+ MOVE_AMNESIA,
+ MOVE_FORESIGHT,
+ MOVE_FUTURE_SIGHT,
+ MOVE_BEAT_UP,
+ MOVE_PSYCH_UP,
+ MOVE_WISH,
+ MOVE_MAGIC_COAT),
+
+ egg_moves(PINECO,
+ MOVE_REFLECT,
+ MOVE_PIN_MISSILE,
+ MOVE_FLAIL,
+ MOVE_SWIFT,
+ MOVE_COUNTER,
+ MOVE_SAND_TOMB),
+
+ egg_moves(DUNSPARCE,
+ MOVE_BIDE,
+ MOVE_ANCIENT_POWER,
+ MOVE_ROCK_SLIDE,
+ MOVE_BITE,
+ MOVE_HEADBUTT,
+ MOVE_ASTONISH,
+ MOVE_CURSE),
+
+ egg_moves(GLIGAR,
+ MOVE_METAL_CLAW,
+ MOVE_WING_ATTACK,
+ MOVE_RAZOR_WIND,
+ MOVE_COUNTER,
+ MOVE_SAND_TOMB),
+
+ egg_moves(SNUBBULL,
+ MOVE_METRONOME,
+ MOVE_FAINT_ATTACK,
+ MOVE_REFLECT,
+ MOVE_PRESENT,
+ MOVE_CRUNCH,
+ MOVE_HEAL_BELL,
+ MOVE_SNORE,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(QWILFISH,
+ MOVE_FLAIL,
+ MOVE_HAZE,
+ MOVE_BUBBLE_BEAM,
+ MOVE_SUPERSONIC,
+ MOVE_ASTONISH),
+
+ egg_moves(SHUCKLE,
+ MOVE_SWEET_SCENT),
+
+ egg_moves(HERACROSS,
+ MOVE_HARDEN,
+ MOVE_BIDE,
+ MOVE_FLAIL,
+ MOVE_FALSE_SWIPE),
+
+ egg_moves(SNEASEL,
+ MOVE_COUNTER,
+ MOVE_SPITE,
+ MOVE_FORESIGHT,
+ MOVE_REFLECT,
+ MOVE_BITE,
+ MOVE_CRUSH_CLAW,
+ MOVE_FAKE_OUT),
+
+ egg_moves(TEDDIURSA,
+ MOVE_CRUNCH,
+ MOVE_TAKE_DOWN,
+ MOVE_SEISMIC_TOSS,
+ MOVE_COUNTER,
+ MOVE_METAL_CLAW,
+ MOVE_FAKE_TEARS,
+ MOVE_YAWN,
+ MOVE_SLEEP_TALK),
+
+ egg_moves(SLUGMA,
+ MOVE_ACID_ARMOR,
+ MOVE_HEAT_WAVE),
+
+ egg_moves(SWINUB,
+ MOVE_TAKE_DOWN,
+ MOVE_BITE,
+ MOVE_BODY_SLAM,
+ MOVE_ROCK_SLIDE,
+ MOVE_ANCIENT_POWER,
+ MOVE_MUD_SHOT,
+ MOVE_ICICLE_SPEAR,
+ MOVE_DOUBLE_EDGE),
+
+ egg_moves(CORSOLA,
+ MOVE_ROCK_SLIDE,
+ MOVE_SCREECH,
+ MOVE_MIST,
+ MOVE_AMNESIA,
+ MOVE_BARRIER,
+ MOVE_INGRAIN,
+ MOVE_CONFUSE_RAY,
+ MOVE_ICICLE_SPEAR),
+
+ egg_moves(REMORAID,
+ MOVE_AURORA_BEAM,
+ MOVE_OCTAZOOKA,
+ MOVE_SUPERSONIC,
+ MOVE_HAZE,
+ MOVE_SCREECH,
+ MOVE_THUNDER_WAVE,
+ MOVE_ROCK_BLAST),
+
+ egg_moves(DELIBIRD,
+ MOVE_AURORA_BEAM,
+ MOVE_QUICK_ATTACK,
+ MOVE_FUTURE_SIGHT,
+ MOVE_SPLASH,
+ MOVE_RAPID_SPIN,
+ MOVE_ICE_BALL),
+
+ egg_moves(MANTINE,
+ MOVE_TWISTER,
+ MOVE_HYDRO_PUMP,
+ MOVE_HAZE,
+ MOVE_SLAM,
+ MOVE_MUD_SPORT,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(SKARMORY,
+ MOVE_DRILL_PECK,
+ MOVE_PURSUIT,
+ MOVE_WHIRLWIND,
+ MOVE_SKY_ATTACK,
+ MOVE_CURSE),
+
+ egg_moves(HOUNDOUR,
+ MOVE_FIRE_SPIN,
+ MOVE_RAGE,
+ MOVE_PURSUIT,
+ MOVE_COUNTER,
+ MOVE_SPITE,
+ MOVE_REVERSAL,
+ MOVE_BEAT_UP,
+ MOVE_WILL_O_WISP),
+
+ egg_moves(PHANPY,
+ MOVE_FOCUS_ENERGY,
+ MOVE_BODY_SLAM,
+ MOVE_ANCIENT_POWER,
+ MOVE_SNORE,
+ MOVE_COUNTER,
+ MOVE_FISSURE),
+
+ egg_moves(STANTLER,
+ MOVE_SPITE,
+ MOVE_DISABLE,
+ MOVE_BITE,
+ MOVE_SWAGGER,
+ MOVE_PSYCH_UP,
+ MOVE_EXTRASENSORY),
+
+ egg_moves(TYROGUE,
+ MOVE_RAPID_SPIN,
+ MOVE_HI_JUMP_KICK,
+ MOVE_MACH_PUNCH,
+ MOVE_MIND_READER,
+ MOVE_HELPING_HAND),
+
+ egg_moves(SMOOCHUM,
+ MOVE_MEDITATE,
+ MOVE_PSYCH_UP,
+ MOVE_FAKE_OUT,
+ MOVE_WISH,
+ MOVE_ICE_PUNCH),
+
+ egg_moves(ELEKID,
+ MOVE_KARATE_CHOP,
+ MOVE_BARRIER,
+ MOVE_ROLLING_KICK,
+ MOVE_MEDITATE,
+ MOVE_CROSS_CHOP,
+ MOVE_FIRE_PUNCH,
+ MOVE_ICE_PUNCH),
+
+ egg_moves(MAGBY,
+ MOVE_KARATE_CHOP,
+ MOVE_MEGA_PUNCH,
+ MOVE_BARRIER,
+ MOVE_SCREECH,
+ MOVE_CROSS_CHOP,
+ MOVE_THUNDER_PUNCH),
+
+ egg_moves(MILTANK,
+ MOVE_PRESENT,
+ MOVE_REVERSAL,
+ MOVE_SEISMIC_TOSS,
+ MOVE_ENDURE,
+ MOVE_PSYCH_UP,
+ MOVE_CURSE,
+ MOVE_HELPING_HAND,
+ MOVE_SLEEP_TALK),
+
+ egg_moves(LARVITAR,
+ MOVE_PURSUIT,
+ MOVE_STOMP,
+ MOVE_OUTRAGE,
+ MOVE_FOCUS_ENERGY,
+ MOVE_ANCIENT_POWER,
+ MOVE_DRAGON_DANCE,
+ MOVE_CURSE),
+
+ egg_moves(TREECKO,
+ MOVE_CRUNCH,
+ MOVE_MUD_SPORT,
+ MOVE_ENDEAVOR,
+ MOVE_LEECH_SEED,
+ MOVE_DRAGON_BREATH,
+ MOVE_CRUSH_CLAW),
+
+ egg_moves(TORCHIC,
+ MOVE_COUNTER,
+ MOVE_REVERSAL,
+ MOVE_ENDURE,
+ MOVE_SWAGGER,
+ MOVE_ROCK_SLIDE,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(MUDKIP,
+ MOVE_REFRESH,
+ MOVE_UPROAR,
+ MOVE_CURSE,
+ MOVE_STOMP,
+ MOVE_ICE_BALL,
+ MOVE_MIRROR_COAT),
+
+ egg_moves(POOCHYENA,
+ MOVE_ASTONISH,
+ MOVE_POISON_FANG,
+ MOVE_COVET,
+ MOVE_LEER,
+ MOVE_YAWN),
+
+ egg_moves(ZIGZAGOON,
+ MOVE_CHARM,
+ MOVE_PURSUIT,
+ MOVE_SUBSTITUTE,
+ MOVE_TICKLE,
+ MOVE_TRICK),
+
+ egg_moves(LOTAD,
+ MOVE_SYNTHESIS,
+ MOVE_RAZOR_LEAF,
+ MOVE_SWEET_SCENT,
+ MOVE_LEECH_SEED,
+ MOVE_FLAIL,
+ MOVE_WATER_GUN),
+
+ egg_moves(SEEDOT,
+ MOVE_LEECH_SEED,
+ MOVE_AMNESIA,
+ MOVE_QUICK_ATTACK,
+ MOVE_RAZOR_WIND,
+ MOVE_TAKE_DOWN,
+ MOVE_FALSE_SWIPE),
+
+ egg_moves(NINCADA,
+ MOVE_ENDURE,
+ MOVE_FAINT_ATTACK,
+ MOVE_GUST,
+ MOVE_SILVER_WIND),
+
+ egg_moves(TAILLOW,
+ MOVE_PURSUIT,
+ MOVE_SUPERSONIC,
+ MOVE_REFRESH,
+ MOVE_MIRROR_MOVE,
+ MOVE_RAGE,
+ MOVE_SKY_ATTACK),
+
+ egg_moves(SHROOMISH,
+ MOVE_FAKE_TEARS,
+ MOVE_SWAGGER,
+ MOVE_CHARM,
+ MOVE_FALSE_SWIPE,
+ MOVE_HELPING_HAND),
+
+ egg_moves(SPINDA,
+ MOVE_ENCORE,
+ MOVE_ROCK_SLIDE,
+ MOVE_ASSIST,
+ MOVE_DISABLE,
+ MOVE_BATON_PASS,
+ MOVE_WISH,
+ MOVE_TRICK,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(WINGULL,
+ MOVE_MIST,
+ MOVE_TWISTER,
+ MOVE_AGILITY,
+ MOVE_GUST,
+ MOVE_WATER_SPORT),
+
+ egg_moves(SURSKIT,
+ MOVE_FORESIGHT,
+ MOVE_MUD_SHOT,
+ MOVE_PSYBEAM,
+ MOVE_HYDRO_PUMP,
+ MOVE_MIND_READER),
+
+ egg_moves(WAILMER,
+ MOVE_DOUBLE_EDGE,
+ MOVE_THRASH,
+ MOVE_SWAGGER,
+ MOVE_SNORE,
+ MOVE_SLEEP_TALK,
+ MOVE_CURSE,
+ MOVE_FISSURE,
+ MOVE_TICKLE),
+
+ egg_moves(SKITTY,
+ MOVE_HELPING_HAND,
+ MOVE_PSYCH_UP,
+ MOVE_UPROAR,
+ MOVE_FAKE_TEARS,
+ MOVE_WISH,
+ MOVE_BATON_PASS,
+ MOVE_SUBSTITUTE,
+ MOVE_TICKLE),
+
+ egg_moves(KECLEON,
+ MOVE_DISABLE,
+ MOVE_MAGIC_COAT,
+ MOVE_TRICK),
+
+ egg_moves(NOSEPASS,
+ MOVE_MAGNITUDE,
+ MOVE_ROLLOUT,
+ MOVE_EXPLOSION),
+
+ egg_moves(TORKOAL,
+ MOVE_ERUPTION,
+ MOVE_ENDURE,
+ MOVE_SLEEP_TALK,
+ MOVE_YAWN),
+
+ egg_moves(SABLEYE,
+ MOVE_PSYCH_UP,
+ MOVE_RECOVER,
+ MOVE_MOONLIGHT),
+
+ egg_moves(BARBOACH,
+ MOVE_THRASH,
+ MOVE_WHIRLPOOL,
+ MOVE_SPARK),
+
+ egg_moves(LUVDISC,
+ MOVE_SPLASH,
+ MOVE_SUPERSONIC,
+ MOVE_WATER_SPORT,
+ MOVE_MUD_SPORT),
+
+ egg_moves(CORPHISH,
+ MOVE_MUD_SPORT,
+ MOVE_ENDEAVOR,
+ MOVE_BODY_SLAM,
+ MOVE_ANCIENT_POWER),
+
+ egg_moves(FEEBAS,
+ MOVE_MIRROR_COAT,
+ MOVE_DRAGON_BREATH,
+ MOVE_MUD_SPORT,
+ MOVE_HYPNOSIS,
+ MOVE_LIGHT_SCREEN,
+ MOVE_CONFUSE_RAY),
+
+ egg_moves(CARVANHA,
+ MOVE_HYDRO_PUMP,
+ MOVE_DOUBLE_EDGE,
+ MOVE_THRASH),
+
+ egg_moves(TRAPINCH,
+ MOVE_FOCUS_ENERGY,
+ MOVE_QUICK_ATTACK,
+ MOVE_GUST),
+
+ egg_moves(MAKUHITA,
+ MOVE_FAINT_ATTACK,
+ MOVE_DETECT,
+ MOVE_FORESIGHT,
+ MOVE_HELPING_HAND,
+ MOVE_CROSS_CHOP,
+ MOVE_REVENGE,
+ MOVE_DYNAMIC_PUNCH,
+ MOVE_COUNTER),
+
+ egg_moves(ELECTRIKE,
+ MOVE_CRUNCH,
+ MOVE_HEADBUTT,
+ MOVE_UPROAR,
+ MOVE_CURSE,
+ MOVE_SWIFT),
+
+ egg_moves(NUMEL,
+ MOVE_HOWL,
+ MOVE_SCARY_FACE,
+ MOVE_BODY_SLAM,
+ MOVE_ROLLOUT,
+ MOVE_DEFENSE_CURL,
+ MOVE_STOMP),
+
+ egg_moves(SPHEAL,
+ MOVE_WATER_SPORT,
+ MOVE_STOCKPILE,
+ MOVE_SWALLOW,
+ MOVE_SPIT_UP,
+ MOVE_YAWN,
+ MOVE_ROCK_SLIDE,
+ MOVE_CURSE,
+ MOVE_FISSURE),
+
+ egg_moves(CACNEA,
+ MOVE_GRASS_WHISTLE,
+ MOVE_ACID,
+ MOVE_TEETER_DANCE,
+ MOVE_DYNAMIC_PUNCH,
+ MOVE_COUNTER),
+
+ egg_moves(SNORUNT,
+ MOVE_BLOCK,
+ MOVE_SPIKES),
+
+ egg_moves(AZURILL,
+ MOVE_ENCORE,
+ MOVE_SING,
+ MOVE_REFRESH,
+ MOVE_SLAM,
+ MOVE_TICKLE),
+
+ egg_moves(SPOINK,
+ MOVE_FUTURE_SIGHT,
+ MOVE_EXTRASENSORY,
+ MOVE_SUBSTITUTE,
+ MOVE_TRICK),
+
+ egg_moves(PLUSLE,
+ MOVE_SUBSTITUTE,
+ MOVE_WISH),
+
+ egg_moves(MINUN,
+ MOVE_SUBSTITUTE,
+ MOVE_WISH),
+
+ egg_moves(MAWILE,
+ MOVE_SWORDS_DANCE,
+ MOVE_FALSE_SWIPE,
+ MOVE_POISON_FANG,
+ MOVE_PSYCH_UP,
+ MOVE_ANCIENT_POWER,
+ MOVE_TICKLE),
+
+ egg_moves(MEDITITE,
+ MOVE_FIRE_PUNCH,
+ MOVE_THUNDER_PUNCH,
+ MOVE_ICE_PUNCH,
+ MOVE_FORESIGHT,
+ MOVE_FAKE_OUT,
+ MOVE_BATON_PASS,
+ MOVE_DYNAMIC_PUNCH),
+
+ egg_moves(SWABLU,
+ MOVE_AGILITY,
+ MOVE_HAZE,
+ MOVE_PURSUIT,
+ MOVE_RAGE),
+
+ egg_moves(DUSKULL,
+ MOVE_IMPRISON,
+ MOVE_DESTINY_BOND,
+ MOVE_PAIN_SPLIT,
+ MOVE_GRUDGE,
+ MOVE_MEMENTO,
+ MOVE_FAINT_ATTACK),
+
+ egg_moves(ROSELIA,
+ MOVE_SPIKES,
+ MOVE_SYNTHESIS,
+ MOVE_PIN_MISSILE,
+ MOVE_COTTON_SPORE),
+
+ egg_moves(SLAKOTH,
+ MOVE_PURSUIT,
+ MOVE_SLASH,
+ MOVE_BODY_SLAM,
+ MOVE_SNORE,
+ MOVE_CRUSH_CLAW,
+ MOVE_CURSE,
+ MOVE_SLEEP_TALK),
+
+ egg_moves(GULPIN,
+ MOVE_DREAM_EATER,
+ MOVE_ACID_ARMOR,
+ MOVE_SMOG,
+ MOVE_PAIN_SPLIT),
+
+ egg_moves(TROPIUS,
+ MOVE_HEADBUTT,
+ MOVE_SLAM,
+ MOVE_RAZOR_WIND,
+ MOVE_LEECH_SEED,
+ MOVE_NATURE_POWER),
+
+ egg_moves(WHISMUR,
+ MOVE_TAKE_DOWN,
+ MOVE_SNORE,
+ MOVE_SWAGGER,
+ MOVE_EXTRASENSORY,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(CLAMPERL,
+ MOVE_REFRESH,
+ MOVE_MUD_SPORT,
+ MOVE_BODY_SLAM,
+ MOVE_SUPERSONIC,
+ MOVE_BARRIER,
+ MOVE_CONFUSE_RAY),
+
+ egg_moves(ABSOL,
+ MOVE_BATON_PASS,
+ MOVE_FAINT_ATTACK,
+ MOVE_DOUBLE_EDGE,
+ MOVE_MAGIC_COAT,
+ MOVE_CURSE,
+ MOVE_SUBSTITUTE),
+
+ egg_moves(SHUPPET,
+ MOVE_DISABLE,
+ MOVE_DESTINY_BOND,
+ MOVE_FORESIGHT,
+ MOVE_ASTONISH,
+ MOVE_IMPRISON),
+
+ egg_moves(SEVIPER,
+ MOVE_STOCKPILE,
+ MOVE_SWALLOW,
+ MOVE_SPIT_UP,
+ MOVE_BODY_SLAM),
+
+ egg_moves(ZANGOOSE,
+ MOVE_FLAIL,
+ MOVE_DOUBLE_KICK,
+ MOVE_RAZOR_WIND,
+ MOVE_COUNTER,
+ MOVE_ROAR,
+ MOVE_CURSE),
+
+ egg_moves(RELICANTH,
+ MOVE_MAGNITUDE,
+ MOVE_SKULL_BASH,
+ MOVE_WATER_SPORT,
+ MOVE_AMNESIA,
+ MOVE_SLEEP_TALK,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(ARON,
+ MOVE_ENDEAVOR,
+ MOVE_BODY_SLAM,
+ MOVE_STOMP,
+ MOVE_SMELLING_SALT),
+
+ egg_moves(CASTFORM,
+ MOVE_FUTURE_SIGHT,
+ MOVE_PSYCH_UP),
+
+ egg_moves(VOLBEAT,
+ MOVE_BATON_PASS,
+ MOVE_SILVER_WIND,
+ MOVE_TRICK),
+
+ egg_moves(ILLUMISE,
+ MOVE_BATON_PASS,
+ MOVE_SILVER_WIND,
+ MOVE_GROWTH),
+
+ egg_moves(LILEEP,
+ MOVE_BARRIER,
+ MOVE_RECOVER,
+ MOVE_MIRROR_COAT,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(ANORITH,
+ MOVE_RAPID_SPIN,
+ MOVE_KNOCK_OFF,
+ MOVE_SWORDS_DANCE,
+ MOVE_ROCK_SLIDE),
+
+ egg_moves(RALTS,
+ MOVE_DISABLE,
+ MOVE_WILL_O_WISP,
+ MOVE_MEAN_LOOK,
+ MOVE_MEMENTO,
+ MOVE_DESTINY_BOND),
+
+ egg_moves(BAGON,
+ MOVE_HYDRO_PUMP,
+ MOVE_THRASH,
+ MOVE_DRAGON_RAGE,
+ MOVE_TWISTER,
+ MOVE_DRAGON_DANCE),
+
+ egg_moves(CHIMECHO,
+ MOVE_DISABLE,
+ MOVE_CURSE,
+ MOVE_HYPNOSIS,
+ MOVE_DREAM_EATER),
+
+ EGG_MOVES_TERMINATOR
+};
diff --git a/src/daycare.c b/src/daycare.c
new file mode 100644
index 000000000..208db4a27
--- /dev/null
+++ b/src/daycare.c
@@ -0,0 +1,1353 @@
+#include "global.h"
+#include "pokemon.h"
+#include "battle.h"
+#include "daycare.h"
+#include "string_util.h"
+#include "constants/species.h"
+#include "constants/items.h"
+#include "mail.h"
+#include "pokemon_storage_system.h"
+#include "event_data.h"
+#include "random.h"
+#include "main.h"
+#include "constants/moves.h"
+#include "egg_hatch.h"
+#include "text.h"
+#include "menu.h"
+#include "new_menu_helpers.h"
+#include "international_string_util.h"
+#include "script.h"
+#include "strings.h"
+#include "task.h"
+#include "window.h"
+#include "party_menu.h"
+#include "list_menu.h"
+#include "overworld.h"
+
+#define EGG_MOVES_ARRAY_COUNT 10
+#define EGG_LVL_UP_MOVES_ARRAY_COUNT 50
+
+extern const u8 gText_MaleSymbol4[];
+extern const u8 gText_FemaleSymbol4[];
+extern const u8 gText_GenderlessSymbol[];
+extern const u8 gText_Lv[];
+extern const u8 gDaycareText_GetAlongVeryWell[];
+extern const u8 gDaycareText_GetAlong[];
+extern const u8 gDaycareText_DontLikeOther[];
+extern const u8 gDaycareText_PlayOther[];
+extern const u8 gExpandedPlaceholder_Empty[];
+
+// this file's functions
+static void ClearDaycareMonMail(struct DayCareMail *mail);
+static void SetInitialEggData(struct Pokemon *mon, u16 species, struct DayCare *daycare);
+static u8 GetDaycareCompatibilityScore(struct DayCare *daycare);
+static void DaycarePrintMonInfo(u8 windowId, s32 daycareSlotId, u8 y);
+
+// RAM buffers used to assist with BuildEggMoveset()
+EWRAM_DATA static u16 sHatchedEggLevelUpMoves[EGG_LVL_UP_MOVES_ARRAY_COUNT] = {0};
+EWRAM_DATA static u16 sHatchedEggFatherMoves[4] = {0};
+EWRAM_DATA static u16 sHatchedEggFinalMoves[4] = {0};
+EWRAM_DATA static u16 sHatchedEggEggMoves[EGG_MOVES_ARRAY_COUNT] = {0};
+EWRAM_DATA static u16 sHatchedEggMotherMoves[4] = {0};
+
+#include "data/pokemon/egg_moves.h"
+
+static const struct WindowTemplate sDaycareLevelMenuWindowTemplate =
+{
+ .priority = 0,
+ .tilemapLeft = 12,
+ .tilemapTop = 1,
+ .width = 17,
+ .height = 5,
+ .paletteNum = 15,
+ .baseBlock = 8
+};
+
+static const struct ListMenuItem sLevelMenuItems[] =
+{
+ {gExpandedPlaceholder_Empty, 0},
+ {gExpandedPlaceholder_Empty, 1},
+ {gOtherText_Exit, 5}
+};
+
+static const struct ListMenuTemplate sDaycareListMenuLevelTemplate =
+{
+ .items = sLevelMenuItems,
+ .moveCursorFunc = ListMenuDefaultCursorMoveFunc,
+ .itemPrintFunc = DaycarePrintMonInfo,
+ .totalItems = 3,
+ .maxShowed = 3,
+ .windowId = 0,
+ .header_X = 2,
+ .item_X = 8,
+ .cursor_X = 0,
+ .upText_Y = 0,
+ .cursorPal = 2,
+ .fillValue = 1,
+ .cursorShadowPal = 3,
+ .lettersSpacing = 1,
+ .itemVerticalPadding = 0,
+ .scrollMultiple = 0,
+ .fontId = 3,
+ .cursorKind = 0
+};
+
+static const u8 *const sCompatibilityMessages[] =
+{
+ gDaycareText_GetAlongVeryWell,
+ gDaycareText_GetAlong,
+ gDaycareText_DontLikeOther,
+ gDaycareText_PlayOther
+};
+
+static const u8 sNewLineText[] = _("\n");
+static const u8 sJapaneseEggNickname[] = _("タマゴ"); // "tamago" ("egg" in Japanese)
+
+// ???
+const u8 sGarbageData[] = {0xF4, 0x4B};
+
+u8 *GetMonNick(struct Pokemon *mon, u8 *dest)
+{
+ u8 nickname[POKEMON_NAME_LENGTH * 2];
+
+ GetMonData(mon, MON_DATA_NICKNAME, nickname);
+ return StringCopy10(dest, nickname);
+}
+
+u8 *GetBoxMonNick(struct BoxPokemon *mon, u8 *dest)
+{
+ u8 nickname[POKEMON_NAME_LENGTH * 2];
+
+ GetBoxMonData(mon, MON_DATA_NICKNAME, nickname);
+ return StringCopy10(dest, nickname);
+}
+
+u8 CountPokemonInDaycare(struct DayCare *daycare)
+{
+ u8 i, count;
+ count = 0;
+
+ for (i = 0; i < DAYCARE_MON_COUNT; i++)
+ {
+ if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) != 0)
+ count++;
+ }
+
+ return count;
+}
+
+void InitDaycareMailRecordMixing(struct DayCare *daycare, struct RecordMixingDayCareMail *daycareMail)
+{
+ u8 i;
+ u8 numDaycareMons = 0;
+
+ for (i = 0; i < DAYCARE_MON_COUNT; i++)
+ {
+ if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) != SPECIES_NONE)
+ {
+ numDaycareMons++;
+ if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_HELD_ITEM) == ITEM_NONE)
+ {
+ daycareMail->holdsItem[i] = FALSE;
+ }
+ else
+ {
+ daycareMail->holdsItem[i] = TRUE;
+ }
+ }
+ else
+ {
+ daycareMail->holdsItem[i] = TRUE;
+ }
+ }
+
+ daycareMail->numDaycareMons = numDaycareMons;
+}
+
+static s8 Daycare_FindEmptySpot(struct DayCare *daycare)
+{
+ u8 i;
+
+ for (i = 0; i < DAYCARE_MON_COUNT; i++)
+ {
+ if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES) == 0)
+ return i;
+ }
+
+ return -1;
+}
+
+static void StorePokemonInDaycare(struct Pokemon *mon, struct DaycareMon *daycareMon)
+{
+ if (MonHasMail(mon))
+ {
+ u8 mailId;
+
+ StringCopy(daycareMon->mail.OT_name, gSaveBlock2Ptr->playerName);
+ GetMonNick(mon, daycareMon->mail.monName);
+// StripExtCtrlCodes(daycareMon->mail.monName);
+// daycareMon->mail.gameLanguage = LANGUAGE_ENGLISH;
+// daycareMon->mail.monLanguage = GetMonData(mon, MON_DATA_LANGUAGE);
+ mailId = GetMonData(mon, MON_DATA_MAIL);
+ daycareMon->mail.message = gSaveBlock1Ptr->mail[mailId];
+ TakeMailFromMon(mon);
+ }
+
+ daycareMon->mon = mon->box;
+ BoxMonRestorePP(&daycareMon->mon);
+ daycareMon->steps = 0;
+ ZeroMonData(mon);
+ CompactPartySlots();
+ CalculatePlayerPartyCount();
+}
+
+static void StorePokemonInEmptyDaycareSlot(struct Pokemon *mon, struct DayCare *daycare)
+{
+ s8 slotId = Daycare_FindEmptySpot(daycare);
+ StorePokemonInDaycare(mon, &daycare->mons[slotId]);
+}
+
+void StoreSelectedPokemonInDaycare(void)
+{
+ u8 monId = GetCursorSelectionMonId();
+ StorePokemonInEmptyDaycareSlot(&gPlayerParty[monId], &gSaveBlock1Ptr->daycare);
+}
+
+// Shifts the second daycare pokemon slot into the first slot.
+static void ShiftDaycareSlots(struct DayCare *daycare)
+{
+ // This condition is only satisfied when the player takes out the first pokemon from the daycare.
+ if (GetBoxMonData(&daycare->mons[1].mon, MON_DATA_SPECIES) != 0
+ && GetBoxMonData(&daycare->mons[0].mon, MON_DATA_SPECIES) == 0)
+ {
+ daycare->mons[0].mon = daycare->mons[1].mon;
+ ZeroBoxMonData(&daycare->mons[1].mon);
+
+ daycare->mons[0].mail = daycare->mons[1].mail;
+ daycare->mons[0].steps = daycare->mons[1].steps;
+ daycare->mons[1].steps = 0;
+ ClearDaycareMonMail(&daycare->mons[1].mail);
+ }
+}
+
+static void ApplyDaycareExperience(struct Pokemon *mon)
+{
+ s32 i;
+ bool8 firstMove;
+ u16 learnedMove;
+
+ for (i = 0; i < MAX_MON_LEVEL; i++)
+ {
+ // Add the mon's gained daycare experience level by level until it can't level up anymore.
+ if (TryIncrementMonLevel(mon))
+ {
+ // Teach the mon new moves it learned while in the daycare.
+ firstMove = TRUE;
+ while ((learnedMove = MonTryLearningNewMove(mon, firstMove)) != 0)
+ {
+ firstMove = FALSE;
+ if (learnedMove == 0xFFFF)
+ {
+ // Mon already knows 4 moves.
+ DeleteFirstMoveAndGiveMoveToMon(mon, gMoveToLearn);
+ }
+ }
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ // Re-calculate the mons stats at its new level.
+ CalculateMonStats(mon);
+}
+
+static u16 TakeSelectedPokemonFromDaycare(struct DaycareMon *daycareMon)
+{
+ u16 species;
+ u32 experience;
+ struct Pokemon pokemon;
+
+ GetBoxMonNick(&daycareMon->mon, gStringVar1);
+ species = GetBoxMonData(&daycareMon->mon, MON_DATA_SPECIES);
+ BoxMonToMon(&daycareMon->mon, &pokemon);
+
+ if (GetMonData(&pokemon, MON_DATA_LEVEL) != MAX_MON_LEVEL)
+ {
+ experience = GetMonData(&pokemon, MON_DATA_EXP) + daycareMon->steps;
+ SetMonData(&pokemon, MON_DATA_EXP, &experience);
+ ApplyDaycareExperience(&pokemon);
+ }
+
+ gPlayerParty[PARTY_SIZE - 1] = pokemon;
+ if (daycareMon->mail.message.itemId)
+ {
+ GiveMailToMon2(&gPlayerParty[PARTY_SIZE - 1], &daycareMon->mail.message);
+ ClearDaycareMonMail(&daycareMon->mail);
+ }
+
+ ZeroBoxMonData(&daycareMon->mon);
+ daycareMon->steps = 0;
+ CompactPartySlots();
+ CalculatePlayerPartyCount();
+ return species;
+}
+
+static u16 TakeSelectedPokemonMonFromDaycareShiftSlots(struct DayCare *daycare, u8 slotId)
+{
+ u16 species = TakeSelectedPokemonFromDaycare(&daycare->mons[slotId]);
+ ShiftDaycareSlots(daycare);
+ return species;
+}
+
+u16 TakePokemonFromDaycare(void)
+{
+ return TakeSelectedPokemonMonFromDaycareShiftSlots(&gSaveBlock1Ptr->daycare, gSpecialVar_0x8004);
+}
+
+static u8 GetLevelAfterDaycareSteps(struct BoxPokemon *mon, u32 steps)
+{
+ struct BoxPokemon tempMon = *mon;
+
+ u32 experience = GetBoxMonData(mon, MON_DATA_EXP) + steps;
+ SetBoxMonData(&tempMon, MON_DATA_EXP, &experience);
+ return GetLevelFromBoxMonExp(&tempMon);
+}
+
+static u8 GetNumLevelsGainedFromSteps(struct DaycareMon *daycareMon)
+{
+ u8 levelBefore;
+ u8 levelAfter;
+
+ levelBefore = GetLevelFromBoxMonExp(&daycareMon->mon);
+ levelAfter = GetLevelAfterDaycareSteps(&daycareMon->mon, daycareMon->steps);
+ return levelAfter - levelBefore;
+}
+
+static u8 GetNumLevelsGainedForDaycareMon(struct DaycareMon *daycareMon)
+{
+ u8 numLevelsGained = GetNumLevelsGainedFromSteps(daycareMon);
+ ConvertIntToDecimalStringN(gStringVar2, numLevelsGained, STR_CONV_MODE_LEFT_ALIGN, 2);
+ GetBoxMonNick(&daycareMon->mon, gStringVar1);
+ return numLevelsGained;
+}
+
+static u32 GetDaycareCostForSelectedMon(struct DaycareMon *daycareMon)
+{
+ u32 cost;
+
+ u8 numLevelsGained = GetNumLevelsGainedFromSteps(daycareMon);
+ GetBoxMonNick(&daycareMon->mon, gStringVar1);
+ cost = 100 + 100 * numLevelsGained;
+ ConvertIntToDecimalStringN(gStringVar2, cost, STR_CONV_MODE_LEFT_ALIGN, 5);
+ return cost;
+}
+
+static u16 GetDaycareCostForMon(struct DayCare *daycare, u8 slotId)
+{
+ return GetDaycareCostForSelectedMon(&daycare->mons[slotId]);
+}
+
+void GetDaycareCost(void)
+{
+ gSpecialVar_0x8005 = GetDaycareCostForMon(&gSaveBlock1Ptr->daycare, gSpecialVar_0x8004);
+}
+
+static void Debug_AddDaycareSteps(u16 numSteps)
+{
+ gSaveBlock1Ptr->daycare.mons[0].steps += numSteps;
+ gSaveBlock1Ptr->daycare.mons[1].steps += numSteps;
+ gSaveBlock1Ptr->route5DayCareMon.steps += numSteps;
+}
+
+u8 GetNumLevelsGainedFromDaycare(void)
+{
+ if (GetBoxMonData(&gSaveBlock1Ptr->daycare.mons[gSpecialVar_0x8004], MON_DATA_SPECIES) != 0)
+ return GetNumLevelsGainedForDaycareMon(&gSaveBlock1Ptr->daycare.mons[gSpecialVar_0x8004]);
+
+ return 0;
+}
+
+static void ClearDaycareMonMail(struct DayCareMail *mail)
+{
+ s32 i;
+
+ for (i = 0; i < PLAYER_NAME_LENGTH; i++)
+ mail->OT_name[i] = 0;
+ for (i = 0; i < POKEMON_NAME_LENGTH + 1; i++)
+ mail->monName[i] = 0;
+
+ ClearMailStruct(&mail->message);
+}
+
+static void ClearDaycareMon(struct DaycareMon *daycareMon)
+{
+ ZeroBoxMonData(&daycareMon->mon);
+ daycareMon->steps = 0;
+ ClearDaycareMonMail(&daycareMon->mail);
+}
+
+static void ClearAllDaycareData(struct DayCare *daycare)
+{
+ u8 i;
+
+ for (i = 0; i < DAYCARE_MON_COUNT; i++)
+ ClearDaycareMon(&daycare->mons[i]);
+
+ daycare->offspringPersonality = 0;
+ daycare->stepCounter = 0;
+}
+
+// Determines what the species of an Egg would be based on the given species.
+// It determines this by working backwards through the evolution chain of the
+// given species.
+static u16 GetEggSpecies(u16 species)
+{
+ int i, j, k;
+ bool8 found;
+
+ // Working backwards up to 5 times seems arbitrary, since the maximum number
+ // of times would only be 3 for 3-stage evolutions.
+ for (i = 0; i < EVOS_PER_MON; i++)
+ {
+ found = FALSE;
+ for (j = 1; j < NUM_SPECIES; j++)
+ {
+ for (k = 0; k < EVOS_PER_MON; k++)
+ {
+ if (gEvolutionTable[j][k].targetSpecies == species)
+ {
+ species = j;
+ found = TRUE;
+ break;
+ }
+ }
+
+ if (found)
+ break;
+ }
+
+ if (j == NUM_SPECIES)
+ break;
+ }
+
+ return species;
+}
+//
+//static s32 GetSlotToInheritNature(struct DayCare *daycare)
+//{
+// u32 species[DAYCARE_MON_COUNT];
+// s32 i;
+// s32 dittoCount;
+// s32 slot = -1;
+//
+// // search for female gender
+// for (i = 0; i < DAYCARE_MON_COUNT; i++)
+// {
+// if (GetBoxMonGender(&daycare->mons[i].mon) == MON_FEMALE)
+// slot = i;
+// }
+//
+// // search for ditto
+// for (dittoCount = 0, i = 0; i < DAYCARE_MON_COUNT; i++)
+// {
+// species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+// if (species[i] == SPECIES_DITTO)
+// dittoCount++, slot = i;
+// }
+//
+// // coin flip on ...two Dittos
+// if (dittoCount == 2)
+// {
+// if (Random() >= USHRT_MAX / 2)
+// slot = 0;
+// else
+// slot = 1;
+// }
+//
+// // nature inheritance only if holds everstone
+// if (GetBoxMonData(&daycare->mons[slot].mon, MON_DATA_HELD_ITEM) != ITEM_EVERSTONE
+// || Random() >= USHRT_MAX / 2)
+// {
+// return -1;
+// }
+//
+// return slot;
+//}
+
+static void _TriggerPendingDaycareEgg(struct DayCare *daycare)
+{
+// s32 natureSlot;
+// s32 natureTries = 0;
+//
+// SeedRng2(gMain.vblankCounter2);
+// natureSlot = GetSlotToInheritNature(daycare);
+//
+// if (natureSlot < 0)
+// {
+// daycare->offspringPersonality = (Random2() << 0x10) | ((Random() % 0xfffe) + 1);
+// }
+// else
+// {
+// u8 wantedNature = GetNatureFromPersonality(GetBoxMonData(&daycare->mons[natureSlot].mon, MON_DATA_PERSONALITY, NULL));
+// u32 personality;
+//
+// do
+// {
+// personality = (Random2() << 0x10) | (Random());
+// if (wantedNature == GetNatureFromPersonality(personality) && personality != 0)
+// break; // we found a personality with the same nature
+//
+// natureTries++;
+// } while (natureTries <= 2400);
+//
+// daycare->offspringPersonality = personality;
+// }
+
+ daycare->offspringPersonality = ((Random()) % 0xFFFE) + 1;
+ FlagSet(FLAG_PENDING_DAYCARE_EGG);
+}
+
+static void _TriggerPendingDaycareMaleEgg(struct DayCare *daycare)
+{
+ daycare->offspringPersonality = (Random()) | (0x8000);
+ FlagSet(FLAG_PENDING_DAYCARE_EGG);
+}
+
+void TriggerPendingDaycareEgg(void)
+{
+ _TriggerPendingDaycareEgg(&gSaveBlock1Ptr->daycare);
+}
+
+static void TriggerPendingDaycareMaleEgg(void)
+{
+ _TriggerPendingDaycareMaleEgg(&gSaveBlock1Ptr->daycare);
+}
+
+// Removes the selected index from the given IV list and shifts the remaining
+// elements to the left.
+static void RemoveIVIndexFromList(u8 *ivs, u8 selectedIv)
+{
+ s32 i, j;
+ u8 temp[NUM_STATS];
+
+ ivs[selectedIv] = 0xFF;
+ for (i = 0; i < NUM_STATS; i++)
+ {
+ temp[i] = ivs[i];
+ }
+
+ j = 0;
+ for (i = 0; i < NUM_STATS; i++)
+ {
+ if (temp[i] != 0xFF)
+ ivs[j++] = temp[i];
+ }
+}
+
+static void InheritIVs(struct Pokemon *egg, struct DayCare *daycare)
+{
+ u8 i;
+ u8 selectedIvs[3];
+ u8 availableIVs[NUM_STATS];
+ u8 whichParent[ARRAY_COUNT(selectedIvs)];
+ u8 iv;
+
+ // Initialize a list of IV indices.
+ for (i = 0; i < NUM_STATS; i++)
+ {
+ availableIVs[i] = i;
+ }
+
+ // Select the 3 IVs that will be inherited.
+ for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+ {
+ // Randomly pick an IV from the available list.
+ selectedIvs[i] = availableIVs[Random() % (NUM_STATS - i)];
+
+ // Remove the selected IV index from the available IV indices.
+ RemoveIVIndexFromList(availableIVs, selectedIvs[i]);
+ }
+
+ // Determine which parent each of the selected IVs should inherit from.
+ for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+ {
+ whichParent[i] = Random() % 2;
+ }
+
+ // Set each of inherited IVs on the egg mon.
+ for (i = 0; i < ARRAY_COUNT(selectedIvs); i++)
+ {
+ switch (selectedIvs[i])
+ {
+ case 0:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_HP_IV);
+ SetMonData(egg, MON_DATA_HP_IV, &iv);
+ break;
+ case 1:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_ATK_IV);
+ SetMonData(egg, MON_DATA_ATK_IV, &iv);
+ break;
+ case 2:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_DEF_IV);
+ SetMonData(egg, MON_DATA_DEF_IV, &iv);
+ break;
+ case 3:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPEED_IV);
+ SetMonData(egg, MON_DATA_SPEED_IV, &iv);
+ break;
+ case 4:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPATK_IV);
+ SetMonData(egg, MON_DATA_SPATK_IV, &iv);
+ break;
+ case 5:
+ iv = GetBoxMonData(&daycare->mons[whichParent[i]].mon, MON_DATA_SPDEF_IV);
+ SetMonData(egg, MON_DATA_SPDEF_IV, &iv);
+ break;
+ }
+ }
+}
+
+// Counts the number of egg moves a pokemon learns and stores the moves in
+// the given array.
+static u8 GetEggMoves(struct Pokemon *pokemon, u16 *eggMoves)
+{
+ u16 eggMoveIdx;
+ u16 numEggMoves;
+ u16 species;
+ u16 i;
+
+ numEggMoves = 0;
+ eggMoveIdx = 0;
+ species = GetMonData(pokemon, MON_DATA_SPECIES);
+ for (i = 0; i < ARRAY_COUNT(gEggMoves) - 1; i++)
+ {
+ if (gEggMoves[i] == species + EGG_MOVES_SPECIES_OFFSET)
+ {
+ eggMoveIdx = i + 1;
+ break;
+ }
+ }
+
+ for (i = 0; i < EGG_MOVES_ARRAY_COUNT; i++)
+ {
+ if (gEggMoves[eggMoveIdx + i] > EGG_MOVES_SPECIES_OFFSET)
+ {
+ // TODO: the curly braces around this if statement are required for a matching build.
+ break;
+ }
+
+ eggMoves[i] = gEggMoves[eggMoveIdx + i];
+ numEggMoves++;
+ }
+
+ return numEggMoves;
+}
+
+static void BuildEggMoveset(struct Pokemon *egg, struct BoxPokemon *father, struct BoxPokemon *mother)
+{
+ u16 numSharedParentMoves;
+ u32 numLevelUpMoves;
+ u16 numEggMoves;
+ u16 i, j;
+
+ numSharedParentMoves = 0;
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ sHatchedEggMotherMoves[i] = 0;
+ sHatchedEggFatherMoves[i] = 0;
+ sHatchedEggFinalMoves[i] = 0;
+ }
+ for (i = 0; i < EGG_MOVES_ARRAY_COUNT; i++)
+ sHatchedEggEggMoves[i] = 0;
+ for (i = 0; i < EGG_LVL_UP_MOVES_ARRAY_COUNT; i++)
+ sHatchedEggLevelUpMoves[i] = 0;
+
+ numLevelUpMoves = GetLevelUpMovesBySpecies(GetMonData(egg, MON_DATA_SPECIES), sHatchedEggLevelUpMoves);
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ sHatchedEggFatherMoves[i] = GetBoxMonData(father, MON_DATA_MOVE1 + i);
+ sHatchedEggMotherMoves[i] = GetBoxMonData(mother, MON_DATA_MOVE1 + i);
+ }
+
+ numEggMoves = GetEggMoves(egg, sHatchedEggEggMoves);
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (sHatchedEggFatherMoves[i] != MOVE_NONE)
+ {
+ for (j = 0; j < numEggMoves; j++)
+ {
+ if (sHatchedEggFatherMoves[i] == sHatchedEggEggMoves[j])
+ {
+ if (GiveMoveToMon(egg, sHatchedEggFatherMoves[i]) == 0xFFFF)
+ DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFatherMoves[i]);
+ break;
+ }
+ }
+ }
+ else
+ {
+ break;
+ }
+ }
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (sHatchedEggFatherMoves[i] != MOVE_NONE)
+ {
+ for (j = 0; j < NUM_TECHNICAL_MACHINES + NUM_HIDDEN_MACHINES; j++)
+ {
+ if (sHatchedEggFatherMoves[i] == ItemIdToBattleMoveId(ITEM_TM01/*_FOCUS_PUNCH*/ + j) && CanMonLearnTMHM(egg, j))
+ {
+ if (GiveMoveToMon(egg, sHatchedEggFatherMoves[i]) == 0xFFFF)
+ DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFatherMoves[i]);
+ }
+ }
+ }
+ }
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (sHatchedEggFatherMoves[i] == MOVE_NONE)
+ break;
+ for (j = 0; j < MAX_MON_MOVES; j++)
+ {
+ if (sHatchedEggFatherMoves[i] == sHatchedEggMotherMoves[j] && sHatchedEggFatherMoves[i] != MOVE_NONE)
+ sHatchedEggFinalMoves[numSharedParentMoves++] = sHatchedEggFatherMoves[i];
+ }
+ }
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (sHatchedEggFinalMoves[i] == MOVE_NONE)
+ break;
+ for (j = 0; j < numLevelUpMoves; j++)
+ {
+ if (sHatchedEggLevelUpMoves[j] != MOVE_NONE && sHatchedEggFinalMoves[i] == sHatchedEggLevelUpMoves[j])
+ {
+ if (GiveMoveToMon(egg, sHatchedEggFinalMoves[i]) == 0xFFFF)
+ DeleteFirstMoveAndGiveMoveToMon(egg, sHatchedEggFinalMoves[i]);
+ break;
+ }
+ }
+ }
+}
+
+static void RemoveEggFromDayCare(struct DayCare *daycare)
+{
+ daycare->offspringPersonality = 0;
+ daycare->stepCounter = 0;
+}
+
+void RejectEggFromDayCare(void)
+{
+ RemoveEggFromDayCare(&gSaveBlock1Ptr->daycare);
+}
+
+static void AlterEggSpeciesWithIncenseItem(u16 *species, struct DayCare *daycare)
+{
+ u16 motherItem, fatherItem;
+ if (*species == SPECIES_WYNAUT || *species == SPECIES_AZURILL)
+ {
+ motherItem = GetBoxMonData(&daycare->mons[0].mon, MON_DATA_HELD_ITEM);
+ fatherItem = GetBoxMonData(&daycare->mons[1].mon, MON_DATA_HELD_ITEM);
+ if (*species == SPECIES_WYNAUT && motherItem != ITEM_LAX_INCENSE && fatherItem != ITEM_LAX_INCENSE)
+ {
+ *species = SPECIES_WOBBUFFET;
+ }
+
+ if (*species == SPECIES_AZURILL && motherItem != ITEM_SEA_INCENSE && fatherItem != ITEM_SEA_INCENSE)
+ {
+ *species = SPECIES_MARILL;
+ }
+ }
+}
+
+/*static void GiveVoltTackleIfLightBall(struct Pokemon *mon, struct DayCare *daycare)
+{
+ u32 motherItem = GetBoxMonData(&daycare->mons[0].mon, MON_DATA_HELD_ITEM);
+ u32 fatherItem = GetBoxMonData(&daycare->mons[1].mon, MON_DATA_HELD_ITEM);
+
+ if (motherItem == ITEM_LIGHT_BALL || fatherItem == ITEM_LIGHT_BALL)
+ {
+ if (GiveMoveToMon(mon, MOVE_VOLT_TACKLE) == 0xFFFF)
+ DeleteFirstMoveAndGiveMoveToMon(mon, MOVE_VOLT_TACKLE);
+ }
+}*/
+
+static u16 DetermineEggSpeciesAndParentSlots(struct DayCare *daycare, u8 *parentSlots)
+{
+ u16 i;
+ u16 species[2];
+ u16 eggSpecies;
+
+ // Determine which of the daycare mons is the mother and father of the egg.
+ // The 0th index of the parentSlots array is considered the mother slot, and the
+ // 1st index is the father slot.
+ for (i = 0; i < 2; i++)
+ {
+ species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+ if (species[i] == SPECIES_DITTO)
+ {
+ parentSlots[0] = i ^ 1;
+ parentSlots[1] = i;
+ }
+ else if (GetBoxMonGender(&daycare->mons[i].mon) == MON_FEMALE)
+ {
+ parentSlots[0] = i;
+ parentSlots[1] = i ^ 1;
+ }
+ }
+
+ eggSpecies = GetEggSpecies(species[parentSlots[0]]);
+ if (eggSpecies == SPECIES_NIDORAN_F && daycare->offspringPersonality & 0x8000)
+ {
+ eggSpecies = SPECIES_NIDORAN_M;
+ }
+ if (eggSpecies == SPECIES_ILLUMISE && daycare->offspringPersonality & 0x8000)
+ {
+ eggSpecies = SPECIES_VOLBEAT;
+ }
+
+ // Make Ditto the "mother" slot if the other daycare mon is male.
+ if (species[parentSlots[1]] == SPECIES_DITTO && GetBoxMonGender(&daycare->mons[parentSlots[0]].mon) != MON_FEMALE)
+ {
+ u8 temp = parentSlots[1];
+ parentSlots[1] = parentSlots[0];
+ parentSlots[0] = temp;
+ }
+
+ return eggSpecies;
+}
+
+static void _GiveEggFromDaycare(struct DayCare *daycare) // give_egg
+{
+ struct Pokemon egg;
+ u16 species;
+ u8 parentSlots[2]; // 0th index is "mother" daycare slot, 1st is "father"
+ bool8 isEgg;
+
+ species = DetermineEggSpeciesAndParentSlots(daycare, parentSlots);
+ AlterEggSpeciesWithIncenseItem(&species, daycare);
+ SetInitialEggData(&egg, species, daycare);
+ InheritIVs(&egg, daycare);
+ BuildEggMoveset(&egg, &daycare->mons[parentSlots[1]].mon, &daycare->mons[parentSlots[0]].mon);
+
+ /*if (species == SPECIES_PICHU)
+ GiveVoltTackleIfLightBall(&egg, daycare);*/
+
+ isEgg = TRUE;
+ SetMonData(&egg, MON_DATA_IS_EGG, &isEgg);
+ gPlayerParty[PARTY_SIZE - 1] = egg;
+ CompactPartySlots();
+ CalculatePlayerPartyCount();
+ RemoveEggFromDayCare(daycare);
+}
+
+void CreateEgg(struct Pokemon *mon, u16 species, bool8 setHotSpringsLocation)
+{
+ u8 metLevel;
+ u16 ball;
+ u8 language;
+ u8 metLocation;
+ u8 isEgg;
+
+ CreateMon(mon, species, EGG_HATCH_LEVEL, 0x20, FALSE, 0, FALSE, 0);
+ metLevel = 0;
+ ball = ITEM_POKE_BALL;
+ language = LANGUAGE_JAPANESE;
+ SetMonData(mon, MON_DATA_POKEBALL, &ball);
+ SetMonData(mon, MON_DATA_NICKNAME, sJapaneseEggNickname);
+ SetMonData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].eggCycles);
+ SetMonData(mon, MON_DATA_MET_LEVEL, &metLevel);
+ SetMonData(mon, MON_DATA_LANGUAGE, &language);
+ if (setHotSpringsLocation)
+ {
+ metLocation = 253; // hot springs; see PokemonSummaryScreen_PrintEggTrainerMemo
+ SetMonData(mon, MON_DATA_MET_LOCATION, &metLocation);
+ }
+
+ isEgg = TRUE;
+ SetMonData(mon, MON_DATA_IS_EGG, &isEgg);
+}
+
+static void SetInitialEggData(struct Pokemon *mon, u16 species, struct DayCare *daycare)
+{
+ u32 personality;
+ u16 ball;
+ u8 metLevel;
+ u8 language;
+
+ personality = daycare->offspringPersonality | (Random() << 16);
+ CreateMon(mon, species, EGG_HATCH_LEVEL, 0x20, TRUE, personality, FALSE, 0);
+ metLevel = 0;
+ ball = ITEM_POKE_BALL;
+ language = LANGUAGE_JAPANESE;
+ SetMonData(mon, MON_DATA_POKEBALL, &ball);
+ SetMonData(mon, MON_DATA_NICKNAME, sJapaneseEggNickname);
+ SetMonData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].eggCycles);
+ SetMonData(mon, MON_DATA_MET_LEVEL, &metLevel);
+ SetMonData(mon, MON_DATA_LANGUAGE, &language);
+}
+
+void GiveEggFromDaycare(void)
+{
+ _GiveEggFromDaycare(&gSaveBlock1Ptr->daycare);
+}
+
+static bool8 _DoEggActions_CheckHatch(struct DayCare *daycare)
+{
+ u32 i, validEggs = 0;
+
+ for (i = 0; i < DAYCARE_MON_COUNT; i++)
+ {
+ if (GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SANITY_HAS_SPECIES))
+ daycare->mons[i].steps++, validEggs++;
+ }
+
+ // try to trigger poke sex
+ if (daycare->offspringPersonality == 0 && validEggs == 2 && (daycare->mons[1].steps & 0xFF) == 0xFF)
+ {
+ u8 loveScore = GetDaycareCompatibilityScore(daycare);
+ if (loveScore > (Random() * 100u) / USHRT_MAX)
+ TriggerPendingDaycareEgg();
+ }
+
+ if (++daycare->stepCounter == 255) // hatch an egg
+ {
+ u32 steps;
+
+ for (i = 0; i < gPlayerPartyCount; i++)
+ {
+ if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+ continue;
+ if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_IS_BAD_EGG))
+ continue;
+
+ steps = GetMonData(&gPlayerParty[i], MON_DATA_FRIENDSHIP);
+ if (steps != 0) // subtract needed steps
+ {
+ steps -= 1;
+
+ SetMonData(&gPlayerParty[i], MON_DATA_FRIENDSHIP, &steps);
+ }
+ else // hatch the egg
+ {
+ gSpecialVar_0x8004 = i;
+ return TRUE;
+ }
+ }
+ }
+
+ return FALSE; // no hatching
+}
+
+bool8 ShouldEggHatch(void)
+{
+ if (GetBoxMonData(&gSaveBlock1Ptr->route5DayCareMon.mon, MON_DATA_SANITY_HAS_SPECIES))
+ gSaveBlock1Ptr->route5DayCareMon.steps++;
+ return _DoEggActions_CheckHatch(&gSaveBlock1Ptr->daycare);
+}
+
+static bool8 IsEggPending(struct DayCare *daycare)
+{
+ return (daycare->offspringPersonality != 0);
+}
+
+// gStringVar1 = first mon's nickname
+// gStringVar2 = second mon's nickname
+// gStringVar3 = first mon trainer's name
+static void _GetDaycareMonNicknames(struct DayCare *daycare)
+{
+ u8 text[12];
+ if (GetBoxMonData(&daycare->mons[0].mon, MON_DATA_SPECIES) != 0)
+ {
+ GetBoxMonNick(&daycare->mons[0].mon, gStringVar1);
+ GetBoxMonData(&daycare->mons[0].mon, MON_DATA_OT_NAME, text);
+ StringCopy(gStringVar3, text);
+ }
+
+ if (GetBoxMonData(&daycare->mons[1].mon, MON_DATA_SPECIES) != 0)
+ {
+ GetBoxMonNick(&daycare->mons[1].mon, gStringVar2);
+ }
+}
+
+u16 GetSelectedMonNickAndSpecies(void)
+{
+ GetBoxMonNick(&gPlayerParty[GetCursorSelectionMonId()].box, gStringVar1);
+ return GetBoxMonData(&gPlayerParty[GetCursorSelectionMonId()].box, MON_DATA_SPECIES);
+}
+
+void GetDaycareMonNicknames(void)
+{
+ _GetDaycareMonNicknames(&gSaveBlock1Ptr->daycare);
+}
+
+u8 GetDaycareState(void)
+{
+ // The daycare can be in 4 possible states:
+ // 0: default state--no deposited mons, no egg
+ // 1: there is an egg waiting for the player to pick it up
+ // 2: there is a single pokemon in the daycare
+ // 3: there are two pokemon in the daycare, no egg
+
+ u8 numMons;
+ if (IsEggPending(&gSaveBlock1Ptr->daycare))
+ {
+ // There is an Egg waiting for the player.
+ return 1;
+ }
+
+ numMons = CountPokemonInDaycare(&gSaveBlock1Ptr->daycare);
+ if (numMons != 0)
+ {
+ return numMons + 1;
+ }
+
+ return 0;
+}
+
+u8 GetDaycarePokemonCount(void)
+{
+ u8 ret = CountPokemonInDaycare(&gSaveBlock1Ptr->daycare);
+ if (ret)
+ return ret;
+
+ return 0;
+}
+
+static bool8 EggGroupsOverlap(u16 *eggGroups1, u16 *eggGroups2)
+{
+ // Determine if the two given egg group lists contain any of the
+ // same egg groups.
+ s32 i, j;
+
+ for (i = 0; i < 2; i++)
+ {
+ for (j = 0; j < 2; j++)
+ {
+ if (eggGroups1[i] == eggGroups2[j])
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static u8 GetDaycareCompatibilityScore(struct DayCare *daycare)
+{
+ u32 i;
+ u16 eggGroups[2][2];
+ u16 species[2];
+ u32 trainerIds[2];
+ u32 genders[2];
+
+ for (i = 0; i < 2; i++)
+ {
+ u32 personality;
+
+ species[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_SPECIES);
+ trainerIds[i] = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_OT_ID);
+ personality = GetBoxMonData(&daycare->mons[i].mon, MON_DATA_PERSONALITY);
+ genders[i] = GetGenderFromSpeciesAndPersonality(species[i], personality);
+ eggGroups[i][0] = gBaseStats[species[i]].eggGroup1;
+ eggGroups[i][1] = gBaseStats[species[i]].eggGroup2;
+ }
+
+ // check unbreedable egg group
+ if (eggGroups[0][0] == EGG_GROUP_UNDISCOVERED || eggGroups[1][0] == EGG_GROUP_UNDISCOVERED)
+ return 0;
+ // two Ditto can't breed
+ if (eggGroups[0][0] == EGG_GROUP_DITTO && eggGroups[1][0] == EGG_GROUP_DITTO)
+ return 0;
+
+ // now that we checked, one ditto can breed with any other mon
+ if (eggGroups[0][0] == EGG_GROUP_DITTO || eggGroups[1][0] == EGG_GROUP_DITTO)
+ {
+ if (trainerIds[0] == trainerIds[1]) // same trainer
+ return 20;
+
+ return 50; // different trainers, more chance of poke sex
+ }
+ else
+ {
+ if (genders[0] == genders[1]) // no homo
+ return 0;
+ if (genders[0] == MON_GENDERLESS || genders[1] == MON_GENDERLESS)
+ return 0;
+ if (!EggGroupsOverlap(eggGroups[0], eggGroups[1])) // not compatible with each other
+ return 0;
+
+ if (species[0] == species[1]) // same species
+ {
+ if (trainerIds[0] == trainerIds[1]) // same species and trainer
+ return 50;
+
+ return 70; // different trainers, same species
+ }
+ else
+ {
+ if (trainerIds[0] != trainerIds[1]) // different trainers, different species
+ return 50;
+
+ return 20; // different species, same trainer
+ }
+ }
+}
+
+static u8 GetDaycareCompatibilityScoreFromSave(void)
+{
+ return GetDaycareCompatibilityScore(&gSaveBlock1Ptr->daycare);
+}
+
+void SetDaycareCompatibilityString(void)
+{
+ u8 whichString;
+ u8 relationshipScore;
+
+ relationshipScore = GetDaycareCompatibilityScoreFromSave();
+ whichString = 0;
+ if (relationshipScore == 0)
+ whichString = 3;
+ if (relationshipScore == 20)
+ whichString = 2;
+ if (relationshipScore == 50)
+ whichString = 1;
+ if (relationshipScore == 70)
+ whichString = 0;
+
+ StringCopy(gStringVar4, sCompatibilityMessages[whichString]);
+}
+
+bool8 NameHasGenderSymbol(const u8 *name, u8 genderRatio)
+{
+ u8 i;
+ u8 symbolsCount[2]; // male, female
+ symbolsCount[0] = symbolsCount[1] = 0;
+
+ for (i = 0; name[i] != EOS; i++)
+ {
+ if (name[i] == CHAR_MALE)
+ symbolsCount[0]++;
+ if (name[i] == CHAR_FEMALE)
+ symbolsCount[1]++;
+ }
+
+ if (genderRatio == MON_MALE && symbolsCount[0] != 0 && symbolsCount[1] == 0)
+ return TRUE;
+ if (genderRatio == MON_FEMALE && symbolsCount[1] != 0 && symbolsCount[0] == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+static u8 *AppendGenderSymbol(u8 *name, u8 gender)
+{
+ if (gender == MON_MALE)
+ {
+ if (!NameHasGenderSymbol(name, MON_MALE))
+ return StringAppend(name, gText_MaleSymbol4);
+ }
+ else if (gender == MON_FEMALE)
+ {
+ if (!NameHasGenderSymbol(name, MON_FEMALE))
+ return StringAppend(name, gText_FemaleSymbol4);
+ }
+
+ return StringAppend(name, gText_GenderlessSymbol);
+}
+
+static u8 *AppendMonGenderSymbol(u8 *name, struct BoxPokemon *boxMon)
+{
+ return AppendGenderSymbol(name, GetBoxMonGender(boxMon));
+}
+
+static void GetDaycareLevelMenuText(struct DayCare *daycare, u8 *dest)
+{
+ u8 monNames[2][20];
+ u8 i;
+
+ *dest = EOS;
+ for (i = 0; i < 2; i++)
+ {
+ GetBoxMonNick(&daycare->mons[i].mon, monNames[i]);
+ AppendMonGenderSymbol(monNames[i], &daycare->mons[i].mon);
+ }
+
+ StringCopy(dest, monNames[0]);
+ StringAppend(dest, sNewLineText);
+ StringAppend(dest, monNames[1]);
+ StringAppend(dest, sNewLineText);
+ StringAppend(dest, gOtherText_Exit);
+}
+
+static void GetDaycareLevelMenuLevelText(struct DayCare *daycare, u8 *dest)
+{
+ u8 i;
+ u8 level;
+ u8 text[20];
+
+ *dest = EOS;
+ for (i = 0; i < 2; i++)
+ {
+ StringAppend(dest, gText_Lv);
+ level = GetLevelAfterDaycareSteps(&daycare->mons[i].mon, daycare->mons[i].steps);
+ ConvertIntToDecimalStringN(text, level, STR_CONV_MODE_LEFT_ALIGN, 3);
+ StringAppend(dest, text);
+ StringAppend(dest, sNewLineText);
+ }
+}
+
+static void DaycareAddTextPrinter(u8 windowId, const u8 *text, u32 x, u32 y)
+{
+ struct TextPrinterTemplate printer;
+
+ printer.currentChar = text;
+ printer.windowId = windowId;
+ printer.fontId = 3;
+ printer.x = x;
+ printer.y = y;
+ printer.currentX = x;
+ printer.currentY = y;
+ printer.unk = 0;
+ gTextFlags.useAlternateDownArrow = 0;
+ printer.letterSpacing = 1;
+ printer.lineSpacing = 1;
+ printer.fgColor = 2;
+ printer.bgColor = 1;
+ printer.shadowColor = 3;
+
+ AddTextPrinter(&printer, 0xFF, NULL);
+}
+
+static void DaycarePrintMonNick(struct DayCare *daycare, u8 windowId, u32 daycareSlotId, u32 y)
+{
+ u8 nick[POKEMON_NAME_LENGTH * 2];
+
+ GetBoxMonNick(&daycare->mons[daycareSlotId].mon, nick);
+ AppendMonGenderSymbol(nick, &daycare->mons[daycareSlotId].mon);
+ DaycareAddTextPrinter(windowId, nick, 8, y);
+}
+
+static void DaycarePrintMonLvl(struct DayCare *daycare, u8 windowId, u32 daycareSlotId, u32 y)
+{
+ u8 level;
+ u32 x;
+ u8 lvlText[12];
+ u8 intText[8];
+
+ strcpy((char *)lvlText, (const char *)gText_Lv);
+ level = GetLevelAfterDaycareSteps(&daycare->mons[daycareSlotId].mon, daycare->mons[daycareSlotId].steps);
+ ConvertIntToDecimalStringN(intText, level, STR_CONV_MODE_LEFT_ALIGN, 3);
+ StringAppend(lvlText, intText);
+ x = 132 - GetStringWidth(3, lvlText, 0);
+ DaycareAddTextPrinter(windowId, lvlText, x, y);
+}
+
+static void DaycarePrintMonInfo(u8 windowId, s32 daycareSlotId, u8 y)
+{
+ if (daycareSlotId < (unsigned) DAYCARE_MON_COUNT)
+ {
+ DaycarePrintMonNick(&gSaveBlock1Ptr->daycare, windowId, daycareSlotId, y);
+ DaycarePrintMonLvl(&gSaveBlock1Ptr->daycare, windowId, daycareSlotId, y);
+ }
+}
+
+#define tMenuListTaskId data[0]
+#define tWindowId data[1]
+
+static void Task_HandleDaycareLevelMenuInput(u8 taskId)
+{
+ u32 input = ListMenuHandleInput(gTasks[taskId].tMenuListTaskId);
+
+ if (gMain.newKeys & A_BUTTON)
+ {
+ switch (input)
+ {
+ case 0:
+ case 1:
+ gSpecialVar_Result = input;
+ break;
+ case 5:
+ gSpecialVar_Result = 2;
+ break;
+ }
+ DestroyListMenu(gTasks[taskId].tMenuListTaskId, NULL, NULL);
+ ClearStdWindowAndFrame(gTasks[taskId].tWindowId, TRUE);
+ RemoveWindow(gTasks[taskId].tWindowId);
+ DestroyTask(taskId);
+ EnableBothScriptContexts();
+ }
+ else if (gMain.newKeys & B_BUTTON)
+ {
+ gSpecialVar_Result = 2;
+ DestroyListMenu(gTasks[taskId].tMenuListTaskId, NULL, NULL);
+ ClearStdWindowAndFrame(gTasks[taskId].tWindowId, TRUE);
+ RemoveWindow(gTasks[taskId].tWindowId);
+ DestroyTask(taskId);
+ EnableBothScriptContexts();
+ }
+}
+
+void ShowDaycareLevelMenu(void)
+{
+ struct ListMenuTemplate menuTemplate;
+ u8 windowId;
+ u8 listMenuTaskId;
+ u8 daycareMenuTaskId;
+
+ windowId = AddWindow(&sDaycareLevelMenuWindowTemplate);
+ DrawStdWindowFrame(windowId, FALSE);
+
+ menuTemplate = sDaycareListMenuLevelTemplate;
+ menuTemplate.windowId = windowId;
+ listMenuTaskId = ListMenuInit(&menuTemplate, 0, 0);
+
+ CopyWindowToVram(windowId, 3);
+
+ daycareMenuTaskId = CreateTask(Task_HandleDaycareLevelMenuInput, 3);
+ gTasks[daycareMenuTaskId].tMenuListTaskId = listMenuTaskId;
+ gTasks[daycareMenuTaskId].tWindowId = windowId;
+}
+
+#undef tMenuListTaskId
+#undef tWindowId
+
+void ChooseSendDaycareMon(void)
+{
+ sub_8128370();
+ gMain.savedCallback = c2_exit_to_overworld_2_switch;
+}
+
+// Route 5 Daycare
+
+void PutMonInRoute5Daycare(void)
+{
+ u8 monIdx = GetCursorSelectionMonId();
+ StorePokemonInDaycare(&gPlayerParty[monIdx], &gSaveBlock1Ptr->route5DayCareMon);
+}
+
+void GetCostToWithdrawRoute5DaycareMon(void)
+{
+ u16 cost = GetDaycareCostForSelectedMon(&gSaveBlock1Ptr->route5DayCareMon);
+ gSpecialVar_0x8005 = cost;
+}
+
+bool8 IsThereMonInRoute5Daycare(void)
+{
+ if (GetBoxMonData(&gSaveBlock1Ptr->route5DayCareMon.mon, MON_DATA_SPECIES) != SPECIES_NONE)
+ return TRUE;
+
+ return FALSE;
+}
+
+u8 GetNumLevelsGainedForRoute5DaycareMon(void)
+{
+ return GetNumLevelsGainedForDaycareMon(&gSaveBlock1Ptr->route5DayCareMon);
+}
+
+u16 TakePokemonFromRoute5Daycare(void)
+{
+ return TakeSelectedPokemonFromDaycare(&gSaveBlock1Ptr->route5DayCareMon);
+}
diff --git a/src/menu2.c b/src/menu2.c
index ec244b8f7..0676fc75e 100644
--- a/src/menu2.c
+++ b/src/menu2.c
@@ -426,9 +426,9 @@ static const u8 gUnknown_845FD54[][5] = {
void box_print(u8 windowId, u8 fontId, u8 x, u8 y, const struct TextColor * color, s8 speed, const u8 * str)
{
- struct TextSubPrinter printer;
+ struct TextPrinterTemplate printer;
- printer.current_text_offset = str;
+ printer.currentChar = str;
printer.windowId = windowId;
printer.fontId = fontId;
printer.x = x;
@@ -437,8 +437,8 @@ void box_print(u8 windowId, u8 fontId, u8 x, u8 y, const struct TextColor * colo
printer.currentY = printer.y;
printer.letterSpacing = GetFontAttribute(fontId, 2);
printer.lineSpacing = GetFontAttribute(fontId, 3);
- printer.fontColor_l = 0;
- printer.fontColor_h = color->bgColor;
+ printer.unk = 0;
+ printer.fgColor = color->bgColor;
printer.bgColor = color->fgColor;
printer.shadowColor = color->shadowColor;
AddTextPrinter(&printer, speed, NULL);
@@ -446,9 +446,9 @@ void box_print(u8 windowId, u8 fontId, u8 x, u8 y, const struct TextColor * colo
void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, const struct TextColor *color, s8 speed, const u8 *str)
{
- struct TextSubPrinter printer;
+ struct TextPrinterTemplate printer;
- printer.current_text_offset = str;
+ printer.currentChar = str;
printer.windowId = windowId;
printer.fontId = fontId;
printer.x = x;
@@ -457,18 +457,18 @@ void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSp
printer.currentY = printer.y;
printer.letterSpacing = letterSpacing;
printer.lineSpacing = lineSpacing;
- printer.fontColor_l = 0;
- printer.fontColor_h = color->bgColor;
+ printer.unk = 0;
+ printer.fgColor = color->bgColor;
printer.bgColor = color->fgColor;
printer.shadowColor = color->shadowColor;
AddTextPrinter(&printer, speed, NULL);
}
-void sub_812E62C(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextSubPrinter *, u16), u8 letterSpacing, u8 lineSpacing)
+void sub_812E62C(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16), u8 letterSpacing, u8 lineSpacing)
{
- struct TextSubPrinter printer;
+ struct TextPrinterTemplate printer;
- printer.current_text_offset = str;
+ printer.currentChar = str;
printer.windowId = windowId;
printer.fontId = fontId;
printer.x = x;
@@ -477,8 +477,8 @@ void sub_812E62C(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, vo
printer.currentY = y;
printer.letterSpacing = letterSpacing;
printer.lineSpacing = lineSpacing;
- printer.fontColor_l = 0;
- printer.fontColor_h = GetFontAttribute(fontId, 5);
+ printer.unk = 0;
+ printer.fgColor = GetFontAttribute(fontId, 5);
printer.bgColor = GetFontAttribute(fontId, 6);
printer.shadowColor = GetFontAttribute(fontId, 7);
AddTextPrinter(&printer, speed, callback);
diff --git a/src/oak_speech.c b/src/oak_speech.c
index f00d683cf..eb87723a6 100644
--- a/src/oak_speech.c
+++ b/src/oak_speech.c
@@ -535,7 +535,7 @@ static void Task_OaksSpeech1(u8 taskId)
break;
case 5:
sOakSpeechResources->textSpeed = GetTextSpeedSetting();
- gTextFlags.flag_0 = TRUE;
+ gTextFlags.canABSpeedUpPrint = TRUE;
decompress_and_copy_tile_data_to_vram(1, sOakSpeechGfx_GameStartHelpUI, 0, 0, 0);
break;
case 6:
@@ -1516,7 +1516,7 @@ static void Task_OakSpeech42(u8 taskId)
sub_8044D80();
Free(sOakSpeechResources);
sOakSpeechResources = NULL;
- gTextFlags.flag_0 = FALSE;
+ gTextFlags.canABSpeedUpPrint = FALSE;
SetMainCallback2(CB2_NewGame);
DestroyTask(taskId);
}
@@ -1600,7 +1600,7 @@ static void CB2_ReturnFromNamingScreen(void)
ShowBg(2);
EnableInterrupts(INTR_FLAG_VBLANK);
SetVBlankCallback(VBlankCB_NewGameOaksSpeech);
- gTextFlags.flag_0 = TRUE;
+ gTextFlags.canABSpeedUpPrint = TRUE;
SetMainCallback2(CB2_NewGameOaksSpeech);
return;
}
diff --git a/src/pokemon.c b/src/pokemon.c
index 9d902f901..0d4042137 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -1415,13 +1415,13 @@ u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data)
case MON_DATA_LANGUAGE:
retVal = boxMon->language;
break;
- case MON_DATA_SANITY_BIT1:
+ case MON_DATA_SANITY_IS_BAD_EGG:
retVal = boxMon->isBadEgg;
break;
- case MON_DATA_SANITY_BIT2:
+ case MON_DATA_SANITY_HAS_SPECIES:
retVal = boxMon->hasSpecies;
break;
- case MON_DATA_SANITY_BIT3:
+ case MON_DATA_SANITY_IS_EGG:
retVal = boxMon->isEgg;
break;
case MON_DATA_OT_NAME:
@@ -1809,13 +1809,13 @@ void SetBoxMonData(struct BoxPokemon *boxMon, s32 field, const void *dataArg)
case MON_DATA_LANGUAGE:
SET8(boxMon->language);
break;
- case MON_DATA_SANITY_BIT1:
+ case MON_DATA_SANITY_IS_BAD_EGG:
SET8(boxMon->isBadEgg);
break;
- case MON_DATA_SANITY_BIT2:
+ case MON_DATA_SANITY_HAS_SPECIES:
SET8(boxMon->hasSpecies);
break;
- case MON_DATA_SANITY_BIT3:
+ case MON_DATA_SANITY_IS_EGG:
SET8(boxMon->isEgg);
break;
case MON_DATA_OT_NAME:
@@ -5223,7 +5223,7 @@ void sub_8043B48(struct Pokemon *mon, int species, u8 unused, u32 data)
}
}
-bool32 sub_8043B90(struct Pokemon *mon)
+bool8 TryIncrementMonLevel(struct Pokemon *mon)
{
u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL);
u8 level = GetMonData(mon, MON_DATA_LEVEL, NULL);
diff --git a/src/quest_log.c b/src/quest_log.c
index 340bef957..366af45f3 100644
--- a/src/quest_log.c
+++ b/src/quest_log.c
@@ -1055,7 +1055,7 @@ void sub_8111438(void)
{
for (r6 = 0; r6 < 30; r6++)
{
- if (GetBoxMonDataFromAnyBox(r3, r6, MON_DATA_SANITY_BIT2))
+ if (GetBoxMonDataFromAnyBox(r3, r6, MON_DATA_SANITY_HAS_SPECIES))
{
sub_808BCB4(r3, r6);
r5--;
@@ -1074,7 +1074,7 @@ void sub_8111438(void)
for (r6 = 0; r6 < IN_BOX_COUNT; r6++)
{
struct BoxPokemon * boxMon = GetBoxedMonPtr(r3, r6);
- if (!GetBoxMonData(boxMon, MON_DATA_SANITY_BIT2))
+ if (!GetBoxMonData(boxMon, MON_DATA_SANITY_HAS_SPECIES))
{
CopyMon(boxMon, &r9->mon.box, sizeof(struct BoxPokemon));
r5++;
@@ -1104,7 +1104,7 @@ u16 sub_8111618(void)
for (i = 0; i < PARTY_SIZE; i++)
{
- if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_BIT2))
+ if (GetMonData(&gPlayerParty[i], MON_DATA_SANITY_HAS_SPECIES))
count++;
}
@@ -1120,7 +1120,7 @@ u16 sub_811164C(void)
{
for (j = 0; j < IN_BOX_COUNT; j++)
{
- if (GetBoxMonDataFromAnyBox(i, j, MON_DATA_SANITY_BIT2))
+ if (GetBoxMonDataFromAnyBox(i, j, MON_DATA_SANITY_HAS_SPECIES))
count++;
}
}
@@ -1599,7 +1599,7 @@ void sub_81120AC(u8 taskId)
gUnknown_203AE94 = (struct UnkStruct_203AE94){};
sub_80696C0();
ScriptContext2_Disable();
- gTextFlags.flag_2 = FALSE;
+ gTextFlags.autoScroll = FALSE;
gUnknown_2036E28 = 0;
sub_8082740(0);
gUnknown_3005ECC = 1;
diff --git a/src/text.c b/src/text.c
index 34ceb92d4..f84420352 100644
--- a/src/text.c
+++ b/src/text.c
@@ -453,7 +453,7 @@ void TextPrinterInitDownArrowCounters(struct TextPrinter *textPrinter)
{
struct TextPrinterSubStruct *subStruct = &textPrinter->sub_union.sub;
- if (gTextFlags.flag_2 == 1)
+ if (gTextFlags.autoScroll == 1)
subStruct->frames_visible_counter = 0;
else
{
@@ -467,7 +467,7 @@ void TextPrinterDrawDownArrow(struct TextPrinter *textPrinter)
struct TextPrinterSubStruct *subStruct = &textPrinter->sub_union.sub;
const u8 *arrowTiles;
- if (gTextFlags.flag_2 == 0)
+ if (gTextFlags.autoScroll == 0)
{
if (subStruct->field_1 != 0)
{
@@ -483,7 +483,7 @@ void TextPrinterDrawDownArrow(struct TextPrinter *textPrinter)
10,
12);
- switch (gTextFlags.flag_1)
+ switch (gTextFlags.useAlternateDownArrow)
{
case 0:
default:
@@ -544,7 +544,7 @@ bool8 TextPrinterWaitAutoMode(struct TextPrinter *textPrinter)
bool16 TextPrinterWaitWithDownArrow(struct TextPrinter *textPrinter)
{
bool8 result = FALSE;
- if (gTextFlags.flag_2 != 0)
+ if (gTextFlags.autoScroll != 0)
{
result = TextPrinterWaitAutoMode(textPrinter);
}
@@ -563,7 +563,7 @@ bool16 TextPrinterWaitWithDownArrow(struct TextPrinter *textPrinter)
bool16 TextPrinterWait(struct TextPrinter *textPrinter)
{
bool16 result = FALSE;
- if (gTextFlags.flag_2 != 0)
+ if (gTextFlags.autoScroll != 0)
{
result = TextPrinterWaitAutoMode(textPrinter);
}
@@ -591,7 +591,7 @@ void DrawDownArrow(u8 windowId, u16 x, u16 y, u8 bgColor, bool8 drawArrow, u8 *c
FillWindowPixelRect(windowId, (bgColor << 4) | bgColor, x, y, 10, 12);
if (drawArrow == 0)
{
- switch (gTextFlags.flag_1)
+ switch (gTextFlags.useAlternateDownArrow)
{
case 0:
default:
diff --git a/src/text_printer.c b/src/text_printer.c
index 04de1af4c..6c124b448 100644
--- a/src/text_printer.c
+++ b/src/text_printer.c
@@ -48,11 +48,11 @@ void DeactivateAllTextPrinters (void)
sTextPrinters[printer].sub_union.sub.active = 0;
}
-u16 AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextSubPrinter *, u16))
+u16 AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16))
{
- struct TextSubPrinter subPrinter;
+ struct TextPrinterTemplate subPrinter;
- subPrinter.current_text_offset = str;
+ subPrinter.currentChar = str;
subPrinter.windowId = windowId;
subPrinter.fontId = fontId;
subPrinter.x = x;
@@ -61,14 +61,14 @@ u16 AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 x, u8
subPrinter.currentY = y;
subPrinter.letterSpacing = gFonts[fontId].letterSpacing;
subPrinter.lineSpacing = gFonts[fontId].lineSpacing;
- subPrinter.fontColor_l = gFonts[fontId].fontColor_l;
- subPrinter.fontColor_h = gFonts[fontId].fontColor_h;
+ subPrinter.unk = gFonts[fontId].unk;
+ subPrinter.fgColor = gFonts[fontId].fgColor;
subPrinter.bgColor = gFonts[fontId].bgColor;
subPrinter.shadowColor = gFonts[fontId].shadowColor;
return AddTextPrinter(&subPrinter, speed, callback);
}
-bool16 AddTextPrinter(struct TextSubPrinter *textSubPrinter, u8 speed, void (*callback)(struct TextSubPrinter *, u16))
+bool16 AddTextPrinter(struct TextPrinterTemplate *textSubPrinter, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16))
{
int i;
u16 j;
@@ -92,7 +92,7 @@ bool16 AddTextPrinter(struct TextSubPrinter *textSubPrinter, u8 speed, void (*ca
sTempTextPrinter.minLetterSpacing = 0;
sTempTextPrinter.japanese = 0;
- GenerateFontHalfRowLookupTable(textSubPrinter->fontColor_h, textSubPrinter->bgColor, textSubPrinter->shadowColor);
+ GenerateFontHalfRowLookupTable(textSubPrinter->fgColor, textSubPrinter->bgColor, textSubPrinter->shadowColor);
if (speed != TEXT_SPEED_FF && speed != 0x0)
{
--sTempTextPrinter.text_speed;
diff --git a/src/tm_case.c b/src/tm_case.c
index 2fc30da2d..177d3320f 100644
--- a/src/tm_case.c
+++ b/src/tm_case.c
@@ -281,7 +281,7 @@ void InitTMCase(u8 type, void (* callback)(void), u8 a2)
sTMCaseStaticResources.savedCallback = callback;
if (a2 != 0xFF)
sTMCaseStaticResources.unk_05 = a2;
- gTextFlags.flag_2 = FALSE;
+ gTextFlags.autoScroll = FALSE;
SetMainCallback2(CB2_SetUpTMCaseUI_Blocking);
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-06 17:08:47 +0000