Merge branch 'decompile_frontier_2' of https://github.com/DizzyEggg/pokeemerald into factory-data

47 files changed, 3496 insertions, 216 deletions

diff --git a/src/battle_factory.c b/src/battle_factory.c
new file mode 100644
index 000000000..f85a14b48
--- /dev/null
+++ b/src/battle_factory.c
@@ -0,0 +1,3280 @@
+#include "global.h"
+#include "sprite.h"
+#include "event_data.h"
+#include "overworld.h"
+#include "random.h"
+#include "battle_tower.h"
+#include "text.h"
+#include "palette.h"
+#include "task.h"
+#include "main.h"
+#include "malloc.h"
+#include "bg.h"
+#include "gpu_regs.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "window.h"
+#include "data2.h"
+#include "decompress.h"
+#include "pokemon_summary_screen.h"
+#include "sound.h"
+#include "pokedex.h"
+#include "blend_palette.h"
+#include "trainer_pokemon_sprites.h"
+#include "constants/battle_frontier.h"
+#include "constants/songs.h"
+
+// Select_ refers to the first Pokemon selection screen where you choose 3 Pokemon.
+// Swap_   refers to the consecutive selection screen where you can keep your Pokemon or swap one with beaten trainer's.
+
+#define MENU_SUMMARY 0
+#define MENU_RENT 1
+#define MENU_DESELECT 1
+#define MENU_OTHERS 2
+#define MENU_OPTIONS_COUNT 3
+
+#define SELECTABLE_MONS_COUNT 6
+
+#define TAG_PAL_BALL_GREY 0x64
+#define TAG_PAL_BALL_SELECTED 0x65
+#define TAG_PAL_66 0x66
+#define TAG_PAL_67 0x67
+
+#define TAG_TILE_64 0x64
+#define TAG_TILE_65 0x65
+#define TAG_TILE_66 0x66
+#define TAG_TILE_67 0x67
+#define TAG_TILE_68 0x68
+#define TAG_TILE_69 0x69
+#define TAG_TILE_6A 0x6A
+#define TAG_TILE_6B 0x6B
+#define TAG_TILE_6C 0x6C
+#define TAG_TILE_6D 0x6D
+
+struct FactorySelecteableMon
+{
+    u16 monSetId;
+    u16 spriteId;
+    u8 selectedId; // 0 - not selected, 1 - first pokemon, 2 - second pokemon, 3 - third pokemon
+    struct Pokemon monData;
+};
+
+struct UnkFactoryStruct
+{
+    u8 field0;
+    u8 field1;
+};
+
+struct FactorySelectMonsStruct
+{
+    u8 menuCursorPos;
+    u8 menuCursor1SpriteId;
+    u8 menuCursor2SpriteId;
+    u8 cursorPos;
+    u8 cursorSpriteId;
+    u8 selectingMonsState;
+    bool8 fromSummaryScreen;
+    u8 yesNoCursorPos;
+    u8 unused8;
+    struct FactorySelecteableMon mons[SELECTABLE_MONS_COUNT];
+    struct UnkFactoryStruct unk294[3];
+    bool8 unk2A0;
+    u8 fadeSpeciesNameTaskId;
+    bool8 unk2A2;
+    u16 unk2A4;
+    bool8 unk2A6;
+    u8 unk2A7;
+    u8 unk2A8;
+    u8 unk2A9;
+};
+
+// 'Action' refers to the 3 Selectable mons, Cancel, Pknm for swap windows.
+#define ACTIONS_PLAYER_SCREEN 0
+#define ACTIONS_ENEMY_SCREEN 1
+
+struct SwapActionIdAndFunc
+{
+    u8 id;
+    void (*func)(u8 taskId);
+};
+
+struct FactorySwapMonsStruct
+{
+    u8 menuCursorPos;
+    u8 menuCursor1SpriteId;
+    u8 menuCursor2SpriteId;
+    u8 cursorPos;
+    u8 cursorSpriteId;
+    u8 ballSpriteIds[3];
+    u8 unk8[2][3];
+    u8 unkE[2][2];
+    u8 playerMonId;
+    u8 enemyMonId;
+    bool8 inEnemyScreen;
+    bool8 fromSummaryScreen;
+    u8 yesNoCursorPos;
+    u8 actionsCount;
+    const struct SwapActionIdAndFunc *actionsData;
+    u8 unk1C;
+    u8 unk1D;
+    u8 unk1E;
+    u8 unk1F;
+    bool8 monSwapped;
+    u8 fadeSpeciesNameTaskId;
+    u8 unk22;
+    u8 unk23;
+    u16 unk24;
+    bool8 unk26;
+    u8 unk27;
+    u8 unk28;
+    u8 unk29;
+    struct UnkFactoryStruct unk2C;
+    bool8 unk30;
+};
+
+extern u8 (*gUnknown_030062E8)(void);
+extern u8 gUnknown_0203CF20;
+
+extern const u16 gBattleFrontierHeldItems[];
+extern const struct FacilityMon gBattleFrontierMons[];
+extern const struct FacilityMon gSlateportBattleTentMons[];
+extern const struct BattleFrontierTrainer gBattleFrontierTrainers[];
+extern const u8 gUnknown_085B18AC[];
+
+extern void SetMonMoveAvoidReturn(struct Pokemon *mon, u16 move, u8 moveSlot);
+
+// This file's functions.
+static void CB2_InitSelectScreen(void);
+static void Select_SetWinRegs(s16 mWin0H, s16 nWin0H, s16 mWin0V, s16 nWin0V);
+static void Select_InitMonsData(void);
+static void Select_InitAllSprites(void);
+static void Select_ShowSummaryMonSprite(void);
+static void Select_PrintSelectMonString(void);
+static void Select_PrintMonSpecies(void);
+static void Select_PrintMonCategory(void);
+static void Select_PrintRentalPkmnString(void);
+static void Select_CopyMonsToPlayerParty(void);
+static void sub_819C4B4(void);
+static void Select_ShowYesNoOptions(void);
+static void sub_819C568(void);
+static void Select_ShowMenuOptions(void);
+static void Select_PrintMenuOptions(void);
+static void Select_PrintYesNoOptions(void);
+static void Task_SelectFadeSpeciesName(u8 taskId);
+static void sub_819C1D0(u8 taskId);
+static void Task_HandleSelectionScreenChooseMons(u8 taskId);
+static void Task_HandleSelectionScreenMenu(u8 taskId);
+static void CreateFrontierFactorySelectableMons(u8 firstMonId);
+static void CreateTentFactorySelectableMons(u8 firstMonId);
+static void Select_SetBallSpritePaletteNum(u8 id);
+void sub_819F444(struct UnkFactoryStruct arg0, bool8 *arg1);
+static void sub_819B958(u8 windowId);
+void sub_819F2B4(u8 *arg0, bool8 *arg1, bool8 swapScreen);
+void sub_819F3F8(struct UnkFactoryStruct arg0, bool8 *arg1, bool8 swapScreen);
+static u8 Select_RunMenuOptionFunc(void);
+static u8 sub_819BC9C(void);
+static u8 Select_OptionSummary(void);
+static u8 Select_OptionOthers(void);
+static u8 Select_OptionRentDeselect(void);
+u8 sub_81A6F70(u8 battleMode, u8 lvlMode);
+u8 sub_81A6CA8(u8 arg0, u8 arg1);
+static bool32 Select_AreSpeciesValid(u16 monSetId);
+void Swap_DestroyAllSprites(void);
+void Swap_ShowYesNoOptions(void);
+void sub_819E8EC(void);
+void sub_819EAC0(void);
+void Swap_UpdateYesNoCursorPosition(s8 direction);
+void Swap_UpdateMenuCursorPosition(s8 direction);
+void sub_819EA64(u8 windowId);
+void sub_819D770(u8 taskId);
+void Task_HandleSwapScreenChooseMons(u8 taskId);
+void sub_819D588(u8 taskId);
+void sub_819F7B4(u8 taskId);
+void Swap_PrintOnInfoWindow(const u8 *str);
+void Swap_ShowMenuOptions(void);
+void Swap_PrintMenuOptions(void);
+void Swap_PrintYesNoOptions(void);
+void Swap_PrintMonSpecies(void);
+void Swap_PrintMonSpecies2(void);
+void Swap_PrintMonSpecies3(void);
+void Swap_PrintMonCategory(void);
+void Swap_InitAllSprites(void);
+void Swap_PrintPkmnSwap(void);
+void sub_819EADC(void);
+void sub_819EAF8(void);
+void CB2_InitSwapScreen(void);
+void Swap_ShowSummaryMonSprite(void);
+void Swap_UpdateActionCursorPosition(s8 direction);
+void Swap_UpdateBallCursorPosition(s8 direction);
+void Swap_RunMenuOptionFunc(u8 taskId);
+void Swap_RunActionFunc(u8 taskId);
+void Task_SwapCantHaveSameMons(u8 taskId);
+void Swap_PrintActionStrings(void);
+void Swap_PrintActionStrings2(void);
+void Swap_PrintOneActionString(u8 which);
+void Swap_InitActions(u8 id);
+void sub_819E838(u8 arg0);
+bool8 Swap_AlreadyHasSameSpecies(u8 monId);
+void sub_819F600(struct Sprite *sprite);
+
+// Ewram variables
+EWRAM_DATA u8 *gUnknown_0203CE2C = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE30 = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE34 = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE38 = NULL;
+EWRAM_DATA struct Pokemon *sFactorySelectMons = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE40 = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE44 = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE48 = NULL;
+EWRAM_DATA u8 *gUnknown_0203CE4C = NULL;
+
+// IWRAM bss
+IWRAM_DATA struct FactorySelectMonsStruct *sFactorySelectScreen;
+IWRAM_DATA void (*gUnknown_03001280)(u8 taskId);
+IWRAM_DATA struct FactorySwapMonsStruct *sFactorySwapScreen;
+
+// Const rom data.
+const u16 gUnknown_0860F13C[] = INCBIN_U16("graphics/unknown/unknown_60F13C.gbapal");
+const u16 gUnknown_0860F15C[] = INCBIN_U16("graphics/unknown/unknown_60F15C.gbapal");
+const u16 gUnknown_0860F17C[] = INCBIN_U16("graphics/unknown/unknown_60F17C.gbapal");
+const u8 gUnknown_0860F1BC[] = INCBIN_U8("graphics/unknown/unknown_60F1BC.4bpp");
+const u8 gUnknown_0860F3BC[] = INCBIN_U8("graphics/unknown/unknown_60F3BC.4bpp");
+const u8 gUnknown_0860F43C[] = INCBIN_U8("graphics/unknown/unknown_60F43C.4bpp");
+const u8 gUnknown_0860F53C[] = INCBIN_U8("graphics/unknown/unknown_60F53C.4bpp");
+const u8 gUnknown_0860F63C[] = INCBIN_U8("graphics/unknown/unknown_60F63C.4bpp");
+const u8 gUnknown_0860F6BC[] = INCBIN_U8("graphics/unknown/unknown_60F6BC.4bpp");
+const u8 gUnknown_0860F7BC[] = INCBIN_U8("graphics/unknown/unknown_60F7BC.4bpp");
+const u8 gUnknown_0860F83C[] = INCBIN_U8("graphics/unknown/unknown_60F83C.4bpp");
+const u8 gUnknown_0860F93C[] = INCBIN_U8("graphics/unknown/unknown_60F93C.4bpp");
+const u8 gUnknown_0860FA3C[] = INCBIN_U8("graphics/unknown/unknown_60FA3C.4bpp");
+const u8 gUnknown_0861023C[] = INCBIN_U8("graphics/unknown/unknown_61023C.bin");
+const u8 gUnknown_0861033C[] = INCBIN_U8("graphics/unknown/unknown_61033C.4bpp");
+const u16 gUnknown_0861039C[] = INCBIN_U16("graphics/unknown/unknown_61039C.gbapal");
+
+const struct SpriteSheet gUnknown_086103BC[] =
+{
+    {gUnknown_0860F3BC, sizeof(gUnknown_0860F3BC), TAG_TILE_65},
+    {gUnknown_0860F43C, sizeof(gUnknown_0860F43C), TAG_TILE_66},
+    {gUnknown_0860F53C, sizeof(gUnknown_0860F53C), TAG_TILE_67},
+    {gUnknown_0860FA3C, sizeof(gUnknown_0860FA3C), TAG_TILE_6D},
+    {},
+};
+
+const struct CompressedSpriteSheet gUnknown_086103E4[] =
+{
+    {gUnknown_085B18AC, 0x800, TAG_TILE_64},
+    {},
+};
+
+const struct SpritePalette gUnknown_086103F4[] =
+{
+    {gUnknown_0860F13C, TAG_PAL_BALL_GREY},
+    {gUnknown_0860F15C, TAG_PAL_BALL_SELECTED},
+    {gUnknown_0860F17C, TAG_PAL_66},
+    {gUnknown_0861039C, TAG_PAL_67},
+    {},
+};
+
+u8 (* const sSelect_MenuOptionFuncs[])(void) =
+{
+    [MENU_SUMMARY] = Select_OptionSummary,
+    [MENU_RENT] /*Or Deselect*/ = Select_OptionRentDeselect,
+    [MENU_OTHERS] = Select_OptionOthers
+};
+
+extern void (* const sSwap_MenuOptionFuncs[])(u8 taskId);
+
+extern const struct BgTemplate gUnknown_08610428[3];
+extern const struct BgTemplate gUnknown_086108B8[4];
+extern const struct WindowTemplate gUnknown_08610434[];
+extern const struct WindowTemplate gUnknown_086108C8[];
+extern const u16 gUnknown_0861046C[];
+extern const u16 gUnknown_08610918[];
+extern const struct SpriteTemplate gUnknown_086105D8;
+extern const struct SpriteTemplate gUnknown_086105F0;
+extern const struct SpriteTemplate gUnknown_08610608;
+extern const struct SpriteTemplate gUnknown_08610620;
+extern const struct SpriteTemplate gUnknown_08610638;
+extern const u8 gUnknown_08610479[];
+extern const u8 gUnknown_08610925[];
+extern const u8 gUnknown_08610476[];
+extern const u8 gUnknown_08610922[];
+extern const struct SpritePalette gUnknown_086106B0[];
+extern const struct SpriteSheet gUnknown_08610650[];
+extern const struct CompressedSpriteSheet gUnknown_086106A0[];
+
+// gfx
+extern const u8 gFrontierFactorySelectMenu_Gfx[];
+extern const u8 gFrontierFactorySelectMenu_Tilemap[];
+extern const u16 gFrontierFactorySelectMenu_Pal[];
+
+// text
+extern const u8 gText_RentalPkmn2[];
+extern const u8 gText_SelectFirstPkmn[];
+extern const u8 gText_SelectSecondPkmn[];
+extern const u8 gText_SelectThirdPkmn[];
+extern const u8 gText_TheseThreePkmnOkay[];
+extern const u8 gText_CantSelectSamePkmn[];
+extern const u8 gText_Summary[];
+extern const u8 gText_Rechoose[];
+extern const u8 gText_Deselect[];
+extern const u8 gText_Rent[];
+extern const u8 gText_Others2[];
+extern const u8 gText_Yes2[];
+extern const u8 gText_Yes3[];
+extern const u8 gText_No2[];
+extern const u8 gText_No3[];
+extern const u8 gText_QuitSwapping[];
+extern const u8 gText_AcceptThisPkmn[];
+extern const u8 gText_SelectPkmnToAccept[];
+extern const u8 gText_SelectPkmnToSwap[];
+extern const u8 gText_PkmnSwap[];
+extern const u8 gText_Swap[];
+extern const u8 gText_Summary2[];
+extern const u8 gText_PkmnForSwap[];
+extern const u8 gText_SamePkmnInPartyAlready[];
+extern const u8 gText_Cancel3[];
+
+// code
+void sub_819A44C(struct Sprite *sprite)
+{
+    if (sprite->oam.paletteNum == IndexOfSpritePaletteTag(TAG_PAL_BALL_SELECTED))
+    {
+        if (sprite->animEnded)
+        {
+            if (sprite->data[0] != 0)
+            {
+                sprite->data[0]--;
+            }
+            else if (Random() % 5 == 0)
+            {
+                StartSpriteAnim(sprite, 0);
+                sprite->data[0] = 32;
+            }
+            else
+            {
+                StartSpriteAnim(sprite, 1);
+            }
+        }
+        else
+        {
+            StartSpriteAnimIfDifferent(sprite, 1);
+        }
+    }
+    else
+    {
+        StartSpriteAnimIfDifferent(sprite, 0);
+    }
+}
+
+static void Select_CB2(void)
+{
+    AnimateSprites();
+    BuildOamBuffer();
+    RunTextPrinters();
+    UpdatePaletteFade();
+    RunTasks();
+}
+
+static void Select_VblankCb(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void sub_819A4F8(void)
+{
+    sFactorySelectScreen = NULL;
+    SetMainCallback2(CB2_InitSelectScreen);
+}
+
+static void CB2_InitSelectScreen(void)
+{
+    u8 taskId;
+
+    switch (gMain.state)
+    {
+    case 0:
+        if (sFactorySelectMons != NULL)
+            FREE_AND_SET_NULL(sFactorySelectMons);
+        SetHBlankCallback(NULL);
+        SetVBlankCallback(NULL);
+        CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, gUnknown_08610428, ARRAY_COUNT(gUnknown_08610428));
+        InitWindows(gUnknown_08610434);
+        DeactivateAllTextPrinters();
+        gMain.state++;
+        break;
+    case 1:
+        gUnknown_0203CE2C = Alloc(0x440);
+        gUnknown_0203CE30 = AllocZeroed(0x440);
+        gUnknown_0203CE34 = Alloc(0x800);
+        gUnknown_0203CE38 = AllocZeroed(0x800);
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        SetGpuReg(REG_OFFSET_BLDCNT, 0);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        SetGpuReg(REG_OFFSET_MOSAIC, 0);
+        SetGpuReg(REG_OFFSET_WIN0H, 0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0);
+        SetGpuReg(REG_OFFSET_WIN1H, 0);
+        SetGpuReg(REG_OFFSET_WIN1V, 0);
+        SetGpuReg(REG_OFFSET_WININ, 0);
+        SetGpuReg(REG_OFFSET_WINOUT, 0);
+        gMain.state++;
+        break;
+    case 2:
+        ResetPaletteFade();
+        ResetSpriteData();
+        ResetTasks();
+        FreeAllSpritePalettes();
+        CpuCopy16(gFrontierFactorySelectMenu_Gfx, gUnknown_0203CE2C, 0x440);
+        CpuCopy16(gUnknown_0861033C, gUnknown_0203CE30, 0x60);
+        LoadBgTiles(1, gUnknown_0203CE2C, 0x440, 0);
+        LoadBgTiles(3, gUnknown_0203CE30, 0x60, 0);
+        CpuCopy16(gFrontierFactorySelectMenu_Tilemap, gUnknown_0203CE34, 0x800);
+        LoadBgTilemap(1, gUnknown_0203CE34, 0x800, 0);
+        LoadPalette(gFrontierFactorySelectMenu_Pal, 0, 0x40);
+        LoadPalette(gUnknown_0861046C, 0xF0, 8);
+        LoadPalette(gUnknown_0861046C, 0xE0, 10);
+        if (sFactorySelectScreen->fromSummaryScreen == TRUE)
+            gPlttBufferUnfaded[228] = sFactorySelectScreen->unk2A4;
+        LoadPalette(gUnknown_0861039C, 0x20, 4);
+        gMain.state++;
+        break;
+    case 3:
+        SetBgTilemapBuffer(3, gUnknown_0203CE38);
+        CopyToBgTilemapBufferRect(3, gUnknown_0861023C, 11, 4, 8, 8);
+        CopyToBgTilemapBufferRect(3, gUnknown_0861023C,  2, 4, 8, 8);
+        CopyToBgTilemapBufferRect(3, gUnknown_0861023C, 20, 4, 8, 8);
+        CopyBgTilemapBufferToVram(3);
+        gMain.state++;
+        break;
+    case 4:
+        LoadSpritePalettes(gUnknown_086103F4);
+        LoadSpriteSheets(gUnknown_086103BC);
+        LoadCompressedObjectPic(gUnknown_086103E4);
+        ShowBg(0);
+        ShowBg(1);
+        SetVBlankCallback(Select_VblankCb);
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, 0);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG1_ON | DISPCNT_OBJ_1D_MAP);
+        if (sFactorySelectScreen->fromSummaryScreen == TRUE)
+        {
+            Select_SetWinRegs(88, 152, 32, 96);
+            ShowBg(3);
+            SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_OBJ);
+            SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4));
+        }
+        else
+        {
+            HideBg(3);
+        }
+        gMain.state++;
+        break;
+    case 5:
+        if (sFactorySelectScreen->fromSummaryScreen == TRUE)
+            sFactorySelectScreen->cursorPos = gUnknown_0203CF20;
+        Select_InitMonsData();
+        Select_InitAllSprites();
+        if (sFactorySelectScreen->fromSummaryScreen == TRUE)
+            Select_ShowSummaryMonSprite();
+        gMain.state++;
+        break;
+    case 6:
+        Select_PrintSelectMonString();
+        PutWindowTilemap(2);
+        gMain.state++;
+        break;
+    case 7:
+        Select_PrintMonCategory();
+        PutWindowTilemap(5);
+        gMain.state++;
+        break;
+    case 8:
+        Select_PrintMonSpecies();
+        PutWindowTilemap(1);
+        gMain.state++;
+        break;
+    case 9:
+        Select_PrintRentalPkmnString();
+        PutWindowTilemap(0);
+        gMain.state++;
+        break;
+    case 10:
+        sFactorySelectScreen->fadeSpeciesNameTaskId = CreateTask(Task_SelectFadeSpeciesName, 0);
+        if (!sFactorySelectScreen->fromSummaryScreen)
+        {
+            gTasks[sFactorySelectScreen->fadeSpeciesNameTaskId].data[0] = 0;
+            taskId = CreateTask(Task_HandleSelectionScreenChooseMons, 0);
+            gTasks[taskId].data[0] = 0;
+        }
+        else
+        {
+            gTasks[sFactorySelectScreen->fadeSpeciesNameTaskId].data[0] = 1;
+            sFactorySelectScreen->unk2A2 = FALSE;
+            taskId = CreateTask(Task_HandleSelectionScreenMenu, 0);
+            gTasks[taskId].data[0] = 13;
+        }
+        SetMainCallback2(Select_CB2);
+        break;
+    }
+}
+
+static void Select_InitMonsData(void)
+{
+    u8 i;
+
+    if (sFactorySelectScreen != NULL)
+        return;
+
+    sFactorySelectScreen = AllocZeroed(sizeof(*sFactorySelectScreen));
+    sFactorySelectScreen->cursorPos = 0;
+    sFactorySelectScreen->selectingMonsState = 1;
+    sFactorySelectScreen->fromSummaryScreen = FALSE;
+    for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+        sFactorySelectScreen->mons[i].selectedId = 0;
+
+    if (gSaveBlock2Ptr->frontier.lvlMode != FRONTIER_LVL_TENT)
+        CreateFrontierFactorySelectableMons(0);
+    else
+        CreateTentFactorySelectableMons(0);
+}
+
+static void Select_InitAllSprites(void)
+{
+    u8 i, cursorPos;
+    s16 x;
+
+    for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+    {
+        sFactorySelectScreen->mons[i].spriteId = CreateSprite(&gUnknown_086105D8, (35 * i) + 32, 64, 1);
+        gSprites[sFactorySelectScreen->mons[i].spriteId].data[0] = 0;
+        Select_SetBallSpritePaletteNum(i);
+    }
+    cursorPos = sFactorySelectScreen->cursorPos;
+    x = gSprites[sFactorySelectScreen->mons[cursorPos].spriteId].pos1.x;
+    sFactorySelectScreen->cursorSpriteId = CreateSprite(&gUnknown_086105F0, x, 88, 0);
+    sFactorySelectScreen->menuCursor1SpriteId = CreateSprite(&gUnknown_08610608, 176, 112, 0);
+    sFactorySelectScreen->menuCursor2SpriteId = CreateSprite(&gUnknown_08610620, 176, 144, 0);
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].invisible = 1;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].invisible = 1;
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].centerToCornerVecX = 0;
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].centerToCornerVecY = 0;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].centerToCornerVecX = 0;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].centerToCornerVecY = 0;
+}
+
+static void Select_DestroyAllSprites(void)
+{
+    u8 i;
+
+    for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+        DestroySprite(&gSprites[sFactorySelectScreen->mons[i].spriteId]);
+
+    DestroySprite(&gSprites[sFactorySelectScreen->cursorSpriteId]);
+    DestroySprite(&gSprites[sFactorySelectScreen->menuCursor1SpriteId]);
+    DestroySprite(&gSprites[sFactorySelectScreen->menuCursor2SpriteId]);
+}
+
+static void Select_UpdateBallCursorPosition(s8 direction)
+{
+    u8 cursorPos;
+    if (direction > 0) // Move cursor right.
+    {
+        if (sFactorySelectScreen->cursorPos != SELECTABLE_MONS_COUNT - 1)
+            sFactorySelectScreen->cursorPos++;
+        else
+            sFactorySelectScreen->cursorPos = 0;
+    }
+    else // Move cursor left.
+    {
+        if (sFactorySelectScreen->cursorPos != 0)
+            sFactorySelectScreen->cursorPos--;
+        else
+            sFactorySelectScreen->cursorPos = SELECTABLE_MONS_COUNT - 1;
+    }
+
+    cursorPos = sFactorySelectScreen->cursorPos;
+    gSprites[sFactorySelectScreen->cursorSpriteId].pos1.x = gSprites[sFactorySelectScreen->mons[cursorPos].spriteId].pos1.x;
+}
+
+static void Select_UpdateMenuCursorPosition(s8 direction)
+{
+    if (direction > 0) // Move cursor down.
+    {
+        if (sFactorySelectScreen->menuCursorPos != MENU_OPTIONS_COUNT - 1)
+            sFactorySelectScreen->menuCursorPos++;
+        else
+            sFactorySelectScreen->menuCursorPos = 0;
+    }
+    else // Move cursor up.
+    {
+        if (sFactorySelectScreen->menuCursorPos != 0)
+            sFactorySelectScreen->menuCursorPos--;
+        else
+            sFactorySelectScreen->menuCursorPos = MENU_OPTIONS_COUNT - 1;
+    }
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.y = (sFactorySelectScreen->menuCursorPos * 16) + 112;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.y = (sFactorySelectScreen->menuCursorPos * 16) + 112;
+}
+
+static void Select_UpdateYesNoCursorPosition(s8 direction)
+{
+    if (direction > 0) // Move cursor down.
+    {
+        if (sFactorySelectScreen->yesNoCursorPos != 1)
+            sFactorySelectScreen->yesNoCursorPos++;
+        else
+            sFactorySelectScreen->yesNoCursorPos = 0;
+    }
+    else // Move cursor up.
+    {
+        if (sFactorySelectScreen->yesNoCursorPos != 0)
+            sFactorySelectScreen->yesNoCursorPos--;
+        else
+            sFactorySelectScreen->yesNoCursorPos = 1;
+    }
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.y = (sFactorySelectScreen->yesNoCursorPos * 16) + 112;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.y = (sFactorySelectScreen->yesNoCursorPos * 16) + 112;
+}
+
+static void Select_HandleMonSelectionChange(void)
+{
+    u8 i, paletteNum;
+    u8 cursorPos = sFactorySelectScreen->cursorPos;
+    if (sFactorySelectScreen->mons[cursorPos].selectedId) // Deselect a mon.
+    {
+        paletteNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_GREY);
+        if (sFactorySelectScreen->selectingMonsState == 3 && sFactorySelectScreen->mons[cursorPos].selectedId == 1)
+        {
+            for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+            {
+                if (sFactorySelectScreen->mons[i].selectedId == 2)
+                    break;
+            }
+            if (i == SELECTABLE_MONS_COUNT)
+                return;
+            else
+                sFactorySelectScreen->mons[i].selectedId = 1;
+        }
+        sFactorySelectScreen->mons[cursorPos].selectedId = 0;
+        sFactorySelectScreen->selectingMonsState--;
+    }
+    else // Select a mon.
+    {
+        paletteNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_SELECTED);
+        sFactorySelectScreen->mons[cursorPos].selectedId = sFactorySelectScreen->selectingMonsState;
+        sFactorySelectScreen->selectingMonsState++;
+    }
+
+    gSprites[sFactorySelectScreen->mons[cursorPos].spriteId].oam.paletteNum = paletteNum;
+}
+
+static void Select_SetBallSpritePaletteNum(u8 id)
+{
+    u8 palNum;
+
+    if (sFactorySelectScreen->mons[id].selectedId)
+        palNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_SELECTED);
+    else
+        palNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_GREY);
+
+    gSprites[sFactorySelectScreen->mons[id].spriteId].oam.paletteNum = palNum;
+}
+
+static void Task_FromSelectScreenToSummaryScreen(u8 taskId)
+{
+    u8 i;
+    u8 currMonId;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 6:
+        gPlttBufferUnfaded[228] = gPlttBufferFaded[228];
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0);
+        gTasks[taskId].data[0] = 7;
+        break;
+    case 7:
+        if (!gPaletteFade.active)
+        {
+            DestroyTask(sFactorySelectScreen->fadeSpeciesNameTaskId);
+            sub_819F444(sFactorySelectScreen->unk294[1], &sFactorySelectScreen->unk2A0);
+            Select_DestroyAllSprites();
+            FREE_AND_SET_NULL(gUnknown_0203CE2C);
+            FREE_AND_SET_NULL(gUnknown_0203CE30);
+            FREE_AND_SET_NULL(gUnknown_0203CE34);
+            FREE_AND_SET_NULL(gUnknown_0203CE38);
+            FreeAllWindowBuffers();
+            gTasks[taskId].data[0] = 8;
+        }
+        break;
+    case 8:
+        sFactorySelectScreen->unk2A4 = gPlttBufferUnfaded[228];
+        DestroyTask(taskId);
+        sFactorySelectScreen->fromSummaryScreen = TRUE;
+        currMonId = sFactorySelectScreen->cursorPos;
+        sFactorySelectMons = AllocZeroed(sizeof(struct Pokemon) * SELECTABLE_MONS_COUNT);
+        for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+            sFactorySelectMons[i] = sFactorySelectScreen->mons[i].monData;
+        ShowPokemonSummaryScreen(1, sFactorySelectMons, currMonId, SELECTABLE_MONS_COUNT - 1, CB2_InitSelectScreen);
+        break;
+    }
+}
+
+static void Task_CloseSelectionScreen(u8 taskId)
+{
+    if (sFactorySelectScreen->unk2A0 != TRUE)
+    {
+        switch (gTasks[taskId].data[0])
+        {
+        case 0:
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0);
+            gTasks[taskId].data[0]++;
+            break;
+        case 1:
+            if (!UpdatePaletteFade())
+            {
+                Select_CopyMonsToPlayerParty();
+                DestroyTask(sFactorySelectScreen->fadeSpeciesNameTaskId);
+                Select_DestroyAllSprites();
+                FREE_AND_SET_NULL(gUnknown_0203CE2C);
+                FREE_AND_SET_NULL(gUnknown_0203CE34);
+                FREE_AND_SET_NULL(gUnknown_0203CE38);
+                FREE_AND_SET_NULL(sFactorySelectScreen);
+                FreeAllWindowBuffers();
+                SetMainCallback2(CB2_ReturnToFieldContinueScript);
+                DestroyTask(taskId);
+            }
+            break;
+        }
+    }
+}
+
+static void Task_HandleSelectionScreenYesNo(u8 taskId)
+{
+    if (sFactorySelectScreen->unk2A0 != TRUE)
+    {
+        switch (gTasks[taskId].data[0])
+        {
+        case 10:
+            sub_819C4B4();
+            gTasks[taskId].data[0] = 4;
+            break;
+        case 4:
+            Select_ShowYesNoOptions();
+            gTasks[taskId].data[0] = 5;
+            break;
+        case 5:
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                if (sFactorySelectScreen->yesNoCursorPos == 0)
+                {
+                    sub_819C568();
+                    gTasks[taskId].data[0] = 0;
+                    gTasks[taskId].func = Task_CloseSelectionScreen;
+                }
+                else
+                {
+                    sub_819B958(4);
+                    sub_819BC9C();
+                    sFactorySelectScreen->unk2A2 = TRUE;
+                    gTasks[taskId].data[0] = 1;
+                    gTasks[taskId].func = Task_HandleSelectionScreenChooseMons;
+                }
+            }
+            else if (gMain.newKeys & B_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                sub_819B958(4);
+                sub_819BC9C();
+                sFactorySelectScreen->unk2A2 = TRUE;
+                gTasks[taskId].data[0] = 1;
+                gTasks[taskId].func = Task_HandleSelectionScreenChooseMons;
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_UP)
+            {
+                PlaySE(SE_SELECT);
+                Select_UpdateYesNoCursorPosition(-1);
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_DOWN)
+            {
+                PlaySE(SE_SELECT);
+                Select_UpdateYesNoCursorPosition(1);
+            }
+            break;
+        }
+    }
+}
+
+static void Task_HandleSelectionScreenMenu(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 2:
+        if (!sFactorySelectScreen->fromSummaryScreen)
+            sub_819F2B4(&sFactorySelectScreen->unk294[1].field1, &sFactorySelectScreen->unk2A0, FALSE);
+        gTasks[taskId].data[0] = 9;
+        break;
+    case 9:
+        if (sFactorySelectScreen->unk2A0 != TRUE)
+        {
+            Select_ShowMenuOptions();
+            sFactorySelectScreen->fromSummaryScreen = FALSE;
+            gTasks[taskId].data[0] = 3;
+        }
+        break;
+    case 3:
+        if (gMain.newKeys & A_BUTTON)
+        {
+            u8 retVal;
+            PlaySE(SE_SELECT);
+            retVal = Select_RunMenuOptionFunc();
+            if (retVal == 1)
+            {
+                sFactorySelectScreen->unk2A2 = TRUE;
+                gTasks[taskId].data[0] = 1;
+                gTasks[taskId].func = Task_HandleSelectionScreenChooseMons;
+            }
+            else if (retVal == 2)
+            {
+                gTasks[taskId].data[0] = 10;
+                gTasks[taskId].func = Task_HandleSelectionScreenYesNo;
+            }
+            else if (retVal == 3)
+            {
+                gTasks[taskId].data[0] = 11;
+                gTasks[taskId].func = Task_HandleSelectionScreenChooseMons;
+            }
+            else
+            {
+                gTasks[taskId].data[0] = 6;
+                gTasks[taskId].func = Task_FromSelectScreenToSummaryScreen;
+            }
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sub_819F3F8(sFactorySelectScreen->unk294[1], &sFactorySelectScreen->unk2A0, FALSE);
+            sub_819B958(3);
+            sFactorySelectScreen->unk2A2 = TRUE;
+            gTasks[taskId].data[0] = 1;
+            gTasks[taskId].func = Task_HandleSelectionScreenChooseMons;
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_UP)
+        {
+            PlaySE(SE_SELECT);
+            Select_UpdateMenuCursorPosition(-1);
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_DOWN)
+        {
+            PlaySE(SE_SELECT);
+            Select_UpdateMenuCursorPosition(1);
+        }
+        break;
+    case 12:
+        if (!gPaletteFade.active)
+        {
+            if (sFactorySelectScreen->fromSummaryScreen == TRUE)
+            {
+                gPlttBufferFaded[228] = sFactorySelectScreen->unk2A4;
+                gPlttBufferUnfaded[228] = gPlttBufferUnfaded[244];
+            }
+            sFactorySelectScreen->fromSummaryScreen = FALSE;
+            gTasks[taskId].data[0] = 3;
+        }
+        break;
+    case 13:
+        Select_ShowMenuOptions();
+        gTasks[taskId].data[0] = 12;
+        break;
+    }
+}
+
+static void Task_HandleSelectionScreenChooseMons(u8 taskId)
+{
+    if (sFactorySelectScreen->unk2A0 != TRUE)
+    {
+        switch (gTasks[taskId].data[0])
+        {
+        case 0:
+            if (!gPaletteFade.active)
+            {
+                gTasks[taskId].data[0] = 1;
+                sFactorySelectScreen->unk2A2 = TRUE;
+            }
+            break;
+        case 1:
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                sFactorySelectScreen->unk2A2 = FALSE;
+                gTasks[taskId].data[0] = 2;
+                gTasks[taskId].func = Task_HandleSelectionScreenMenu;
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_LEFT)
+            {
+                PlaySE(SE_SELECT);
+                Select_UpdateBallCursorPosition(-1);
+                Select_PrintMonCategory();
+                Select_PrintMonSpecies();
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_RIGHT)
+            {
+                PlaySE(SE_SELECT);
+                Select_UpdateBallCursorPosition(1);
+                Select_PrintMonCategory();
+                Select_PrintMonSpecies();
+            }
+            break;
+        case 11:
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                sub_819F3F8(sFactorySelectScreen->unk294[1], &sFactorySelectScreen->unk2A0, FALSE);
+                Select_PrintSelectMonString();
+                sFactorySelectScreen->unk2A2 = TRUE;
+                gTasks[taskId].data[0] = 1;
+            }
+            break;
+        }
+    }
+}
+
+static void CreateFrontierFactorySelectableMons(u8 firstMonId)
+{
+    u8 i, j = 0;
+    u8 ivs = 0;
+    u8 level = 0;
+    u8 happiness = 0;
+    u32 otId = 0;
+    u8 battleMode = VarGet(VAR_FRONTIER_BATTLE_MODE);
+    u8 lvlMode = gSaveBlock2Ptr->frontier.lvlMode;
+    u8 var_2C = gSaveBlock2Ptr->frontier.field_DE2[battleMode][lvlMode] / 7;
+    u8 var_28 = 0;
+
+    gFacilityTrainerMons = gBattleFrontierMons;
+    if (gSaveBlock2Ptr->frontier.lvlMode != FRONTIER_LVL_50)
+        level = 100;
+    else
+        level = 50;
+
+    var_28 = sub_81A6F70(battleMode, lvlMode);
+    otId = T1_READ_32(gSaveBlock2Ptr->playerTrainerId);
+
+    for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+    {
+        u16 monSetId = gSaveBlock2Ptr->frontier.field_E70[i].monId;
+        sFactorySelectScreen->mons[i + firstMonId].monSetId = monSetId;
+        if (i < var_28)
+            ivs = sub_81A6CA8(var_2C + 1, 0);
+        else
+            ivs = sub_81A6CA8(var_2C, 0);
+        CreateMonWithEVSpreadPersonalityOTID(&sFactorySelectScreen->mons[i + firstMonId].monData,
+                                             gFacilityTrainerMons[monSetId].species,
+                                             level,
+                                             gFacilityTrainerMons[monSetId].nature,
+                                             ivs,
+                                             gFacilityTrainerMons[monSetId].evSpread,
+                                             otId);
+        happiness = 0;
+        for (j = 0; j < 4; j++)
+            SetMonMoveAvoidReturn(&sFactorySelectScreen->mons[i + firstMonId].monData, gFacilityTrainerMons[monSetId].moves[j], j);
+        SetMonData(&sFactorySelectScreen->mons[i + firstMonId].monData, MON_DATA_FRIENDSHIP, &happiness);
+        SetMonData(&sFactorySelectScreen->mons[i + firstMonId].monData, MON_DATA_HELD_ITEM, &gBattleFrontierHeldItems[gFacilityTrainerMons[monSetId].itemTableId]);
+    }
+}
+
+static void CreateTentFactorySelectableMons(u8 firstMonId)
+{
+    u8 i, j;
+    u8 ivs = 0;
+    u8 level = 30;
+    u8 happiness = 0;
+    u32 otId = 0;
+
+    gFacilityTrainerMons = gSlateportBattleTentMons;
+    otId = T1_READ_32(gSaveBlock2Ptr->playerTrainerId);
+
+    for (i = 0; i < SELECTABLE_MONS_COUNT; i++)
+    {
+        u16 monSetId = gSaveBlock2Ptr->frontier.field_E70[i].monId;
+        sFactorySelectScreen->mons[i + firstMonId].monSetId = monSetId;
+        CreateMonWithEVSpreadPersonalityOTID(&sFactorySelectScreen->mons[i + firstMonId].monData,
+                                             gFacilityTrainerMons[monSetId].species,
+                                             level,
+                                             gFacilityTrainerMons[monSetId].nature,
+                                             ivs,
+                                             gFacilityTrainerMons[monSetId].evSpread,
+                                             otId);
+        happiness = 0;
+        for (j = 0; j < 4; j++)
+            SetMonMoveAvoidReturn(&sFactorySelectScreen->mons[i + firstMonId].monData, gFacilityTrainerMons[monSetId].moves[j], j);
+        SetMonData(&sFactorySelectScreen->mons[i + firstMonId].monData, MON_DATA_FRIENDSHIP, &happiness);
+        SetMonData(&sFactorySelectScreen->mons[i + firstMonId].monData, MON_DATA_HELD_ITEM, &gBattleFrontierHeldItems[gFacilityTrainerMons[monSetId].itemTableId]);
+    }
+}
+
+static void Select_CopyMonsToPlayerParty(void)
+{
+    u8 i, j;
+
+    for (i = 0; i < 3; i++)
+    {
+        for (j = 0; j < SELECTABLE_MONS_COUNT; j++)
+        {
+            if (sFactorySelectScreen->mons[j].selectedId == i + 1)
+            {
+                gPlayerParty[i] = sFactorySelectScreen->mons[j].monData;
+                gSaveBlock2Ptr->frontier.field_E70[i].monId = sFactorySelectScreen->mons[j].monSetId;
+                gSaveBlock2Ptr->frontier.field_E70[i].personality = GetMonData(&gPlayerParty[i].box, MON_DATA_PERSONALITY, NULL);
+                gSaveBlock2Ptr->frontier.field_E70[i].abilityBit = GetBoxMonData(&gPlayerParty[i].box, MON_DATA_ALT_ABILITY, NULL);
+                gSaveBlock2Ptr->frontier.field_E70[i].ivs = GetBoxMonData(&gPlayerParty[i].box, MON_DATA_ATK_IV, NULL);
+                break;
+            }
+        }
+    }
+    CalculatePlayerPartyCount();
+}
+
+static void Select_ShowMenuOptions(void)
+{
+    if (!sFactorySelectScreen->fromSummaryScreen)
+        sFactorySelectScreen->menuCursorPos = 0;
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.x = 176;
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.y = (sFactorySelectScreen->menuCursorPos * 16) + 112;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.x = 208;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.y = (sFactorySelectScreen->menuCursorPos * 16) + 112;
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].invisible = 0;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].invisible = 0;
+
+    Select_PrintMenuOptions();
+}
+
+static void Select_ShowYesNoOptions(void)
+{
+    sFactorySelectScreen->yesNoCursorPos = 0;
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.x = 176;
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].pos1.y = 112;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.x = 208;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].pos1.y = 112;
+
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].invisible = 0;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].invisible = 0;
+
+    Select_PrintYesNoOptions();
+}
+
+static void sub_819B958(u8 windowId)
+{
+    gSprites[sFactorySelectScreen->menuCursor1SpriteId].invisible = 1;
+    gSprites[sFactorySelectScreen->menuCursor2SpriteId].invisible = 1;
+    FillWindowPixelBuffer(windowId, 0);
+    CopyWindowToVram(windowId, 2);
+    ClearWindowTilemap(windowId);
+}
+
+static void Select_PrintRentalPkmnString(void)
+{
+    FillWindowPixelBuffer(0, 0);
+    AddTextPrinterParameterized(0, 1, gText_RentalPkmn2, 2, 1, 0, NULL);
+    CopyWindowToVram(0, 3);
+}
+
+static void Select_PrintMonSpecies(void)
+{
+    u16 species;
+    u8 x;
+    u8 monId = sFactorySelectScreen->cursorPos;
+
+    FillWindowPixelBuffer(1, 0);
+    species = GetMonData(&sFactorySelectScreen->mons[monId].monData, MON_DATA_SPECIES, NULL);
+    StringCopy(gStringVar4, gSpeciesNames[species]);
+    x = GetStringRightAlignXOffset(1, gStringVar4, 86);
+    AddTextPrinterParameterized3(1, 1, x, 1, gUnknown_08610479, 0, gStringVar4);
+    CopyWindowToVram(1, 2);
+}
+
+static void Select_PrintSelectMonString(void)
+{
+    const u8 *str = NULL;
+
+    FillWindowPixelBuffer(2, 0);
+    if (sFactorySelectScreen->selectingMonsState == 1)
+        str = gText_SelectFirstPkmn;
+    else if (sFactorySelectScreen->selectingMonsState == 2)
+        str = gText_SelectSecondPkmn;
+    else if (sFactorySelectScreen->selectingMonsState == 3)
+        str = gText_SelectThirdPkmn;
+    else
+        str = gText_TheseThreePkmnOkay;
+
+    AddTextPrinterParameterized(2, 1, str, 2, 5, 0, NULL);
+    CopyWindowToVram(2, 2);
+}
+
+static void Select_PrintCantSelectSameMon(void)
+{
+    FillWindowPixelBuffer(2, 0);
+    AddTextPrinterParameterized(2, 1, gText_CantSelectSamePkmn, 2, 5, 0, NULL);
+    CopyWindowToVram(2, 2);
+}
+
+static void Select_PrintMenuOptions(void)
+{
+    u8 selectedId = sFactorySelectScreen->mons[sFactorySelectScreen->cursorPos].selectedId;
+
+    PutWindowTilemap(3);
+    FillWindowPixelBuffer(3, 0);
+    AddTextPrinterParameterized3(3, 1, 7, 1, gUnknown_08610476, 0, gText_Summary);
+    if (selectedId != 0)
+        AddTextPrinterParameterized3(3, 1, 7, 17, gUnknown_08610476, 0, gText_Deselect);
+    else
+        AddTextPrinterParameterized3(3, 1, 7, 17, gUnknown_08610476, 0, gText_Rent);
+
+    AddTextPrinterParameterized3(3, 1, 7, 33, gUnknown_08610476, 0, gText_Others2);
+    CopyWindowToVram(3, 3);
+}
+
+static void Select_PrintYesNoOptions(void)
+{
+    PutWindowTilemap(4);
+    FillWindowPixelBuffer(4, 0);
+    AddTextPrinterParameterized3(4, 1, 7, 1, gUnknown_08610476, 0, gText_Yes2);
+    AddTextPrinterParameterized3(4, 1, 7, 17, gUnknown_08610476, 0, gText_No2);
+    CopyWindowToVram(4, 3);
+}
+
+static u8 Select_RunMenuOptionFunc(void)
+{
+    gUnknown_030062E8 = sSelect_MenuOptionFuncs[sFactorySelectScreen->menuCursorPos];
+    return gUnknown_030062E8();
+}
+
+static u8 Select_OptionRentDeselect(void)
+{
+    u8 selectedId = sFactorySelectScreen->mons[sFactorySelectScreen->cursorPos].selectedId;
+    u16 monSetId  = sFactorySelectScreen->mons[sFactorySelectScreen->cursorPos].monSetId;
+    if (selectedId == 0 && !Select_AreSpeciesValid(monSetId))
+    {
+        Select_PrintCantSelectSameMon();
+        sub_819B958(3);
+        return 3;
+    }
+    else
+    {
+        sub_819F3F8(sFactorySelectScreen->unk294[1], &sFactorySelectScreen->unk2A0, FALSE);
+        Select_HandleMonSelectionChange();
+        Select_PrintSelectMonString();
+        sub_819B958(3);
+        if (sFactorySelectScreen->selectingMonsState > 3)
+            return 2;
+        else
+            return 1;
+    }
+}
+
+static u8 sub_819BC9C(void)
+{
+    sub_819C568();
+    Select_HandleMonSelectionChange();
+    Select_PrintSelectMonString();
+    sub_819B958(3);
+    if (sFactorySelectScreen->selectingMonsState > 3)
+        return 2;
+    else
+        return 1;
+}
+
+static u8 Select_OptionSummary(void)
+{
+    return 0;
+}
+
+static u8 Select_OptionOthers(void)
+{
+    sub_819F3F8(sFactorySelectScreen->unk294[1], &sFactorySelectScreen->unk2A0, FALSE);
+    sub_819B958(3);
+    return 1;
+}
+
+static void Select_PrintMonCategory(void)
+{
+    u16 species;
+    u8 text[30];
+    u8 x;
+    u8 monId = sFactorySelectScreen->cursorPos;
+    if (monId < SELECTABLE_MONS_COUNT)
+    {
+        PutWindowTilemap(5);
+        FillWindowPixelBuffer(5, 0);
+        species = GetMonData(&sFactorySelectScreen->mons[monId].monData, MON_DATA_SPECIES, NULL);
+        CopyMonCategoryText(SpeciesToNationalPokedexNum(species), text);
+        x = GetStringRightAlignXOffset(1, text, 0x76);
+        AddTextPrinterParameterized(5, 1, text, x, 1, 0, NULL);
+        CopyWindowToVram(5, 2);
+    }
+}
+
+void sub_819BD70(void)
+{
+    u8 monId = sFactorySelectScreen->cursorPos;
+    struct Pokemon *mon = &sFactorySelectScreen->mons[monId].monData;
+    u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL);
+    u32 personality = GetMonData(mon, MON_DATA_PERSONALITY, NULL);
+    u32 otId = GetMonData(mon, MON_DATA_OT_ID, NULL);
+
+    sFactorySelectScreen->unk294[1].field0 = CreateMonPicSprite_HandleDeoxys(species, otId, personality, TRUE, 88, 32, 15, 0xFFFF);
+    gSprites[sFactorySelectScreen->unk294[1].field0].centerToCornerVecX = 0;
+    gSprites[sFactorySelectScreen->unk294[1].field0].centerToCornerVecY = 0;
+
+    sFactorySelectScreen->unk2A0 = FALSE;
+}
+
+void sub_819BE20(bool8 arg0)
+{
+    sFactorySelectScreen->unk2A0 = arg0;
+}
+
+static void Select_ShowSummaryMonSprite(void)
+{
+    struct Pokemon *mon;
+    u16 species;
+    u32 personality, otId;
+
+    sFactorySelectScreen->unk294[1].field1 = CreateSprite(&gUnknown_08610638, 120, 64, 1);
+    StartSpriteAffineAnim(&gSprites[sFactorySelectScreen->unk294[1].field1], 2);
+
+    mon = &sFactorySelectScreen->mons[sFactorySelectScreen->cursorPos].monData;
+    species = GetMonData(mon, MON_DATA_SPECIES, NULL);
+    personality = GetMonData(mon, MON_DATA_PERSONALITY, NULL);
+    otId = GetMonData(mon, MON_DATA_OT_ID, NULL);
+
+    sFactorySelectScreen->unk294[1].field0 = CreateMonPicSprite_HandleDeoxys(species, otId, personality, TRUE, 88, 32, 15, 0xFFFF);
+    gSprites[sFactorySelectScreen->unk294[1].field0].centerToCornerVecX = 0;
+    gSprites[sFactorySelectScreen->unk294[1].field0].centerToCornerVecY = 0;
+
+    gSprites[sFactorySelectScreen->unk294[1].field1].invisible = 1;
+}
+
+static void Select_ShowChosenMonsSprites(void)
+{
+    u8 i, j;
+
+    for (i = 0; i < 3; i++)
+    {
+        for (j = 0; j < SELECTABLE_MONS_COUNT; j++)
+        {
+            if (sFactorySelectScreen->mons[j].selectedId == i + 1)
+            {
+                struct Pokemon *mon = &sFactorySelectScreen->mons[j].monData;
+                u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL);
+                u32 personality = GetMonData(mon, MON_DATA_PERSONALITY, NULL);
+                u32 otId = GetMonData(mon, MON_DATA_OT_ID, NULL);
+
+                sFactorySelectScreen->unk294[i].field0 = CreateMonPicSprite_HandleDeoxys(species, otId, personality, TRUE, (i * 72) + 16, 32, i + 13, 0xFFFF);
+                gSprites[sFactorySelectScreen->unk294[i].field0].centerToCornerVecX = 0;
+                gSprites[sFactorySelectScreen->unk294[i].field0].centerToCornerVecY = 0;
+                break;
+            }
+        }
+    }
+    sFactorySelectScreen->unk2A0 = FALSE;
+}
+
+static void sub_819C040(struct Sprite *sprite)
+{
+    u8 taskId;
+
+    if (sprite->affineAnimEnded
+        && gSprites[sFactorySelectScreen->unk294[0].field1].affineAnimEnded
+        && gSprites[sFactorySelectScreen->unk294[2].field1].affineAnimEnded)
+    {
+        sprite->invisible = 1;
+        gSprites[sFactorySelectScreen->unk294[0].field1].invisible = 1;
+        gSprites[sFactorySelectScreen->unk294[2].field1].invisible = 1;
+
+        taskId = CreateTask(sub_819C1D0, 1);
+        gTasks[taskId].func(taskId);
+
+        sprite->callback = SpriteCallbackDummy;
+    }
+}
+
+static void sub_819C100(struct Sprite *sprite)
+{
+    if (sprite->affineAnimEnded
+        && gSprites[sFactorySelectScreen->unk294[0].field1].affineAnimEnded
+        && gSprites[sFactorySelectScreen->unk294[2].field1].affineAnimEnded)
+    {
+        FreeOamMatrix(sprite->oam.matrixNum);
+        FreeOamMatrix(gSprites[sFactorySelectScreen->unk294[0].field1].oam.matrixNum);
+        FreeOamMatrix(gSprites[sFactorySelectScreen->unk294[2].field1].oam.matrixNum);
+
+        sFactorySelectScreen->unk2A0 = FALSE;
+
+        DestroySprite(&gSprites[sFactorySelectScreen->unk294[0].field1]);
+        DestroySprite(&gSprites[sFactorySelectScreen->unk294[2].field1]);
+        DestroySprite(sprite);
+    }
+}
+
+static void sub_819C1D0(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    case 0:
+        task->data[3] = 16;
+        task->data[24] = 224; // BUG: writing outside the array's bounds.
+        task->data[5] = 64;
+        task->data[8] = 65;
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        SetGpuReg(REG_OFFSET_WIN0H, WINHV_COORDS(task->data[3], task->data[24]));
+        SetGpuReg(REG_OFFSET_WIN0V, WINHV_COORDS(task->data[5], task->data[8]));
+        SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_CLR | WININ_WIN0_OBJ);
+        SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_CLR | WINOUT_WIN01_OBJ);
+        break;
+    case 1:
+        ShowBg(3);
+        SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_OBJ);
+        SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4));
+        break;
+    case 2:
+        task->data[5] -= 4;
+        task->data[8] += 4;
+        if (task->data[5] <= 32 || task->data[8] >= 96)
+        {
+            task->data[5] = 32;
+            task->data[8] = 96;
+            ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        }
+        SetGpuReg(REG_OFFSET_WIN0V, WINHV_COORDS(task->data[5], task->data[8]));
+        if (task->data[5] != 32)
+            return;
+        break;
+    default:
+        DestroyTask(taskId);
+        Select_ShowChosenMonsSprites();
+        return;
+    }
+    task->data[0]++;
+}
+
+static void sub_819C2D4(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    switch (task->data[0])
+    {
+    default:
+        HideBg(3);
+        gSprites[sFactorySelectScreen->unk294[1].field1].invisible = 0;
+        gSprites[sFactorySelectScreen->unk294[1].field1].callback = sub_819C100;
+        gSprites[sFactorySelectScreen->unk294[0].field1].invisible = 0;
+        gSprites[sFactorySelectScreen->unk294[0].field1].callback = SpriteCallbackDummy;
+        gSprites[sFactorySelectScreen->unk294[2].field1].invisible = 0;
+        gSprites[sFactorySelectScreen->unk294[2].field1].callback = SpriteCallbackDummy;
+        StartSpriteAffineAnim(&gSprites[sFactorySelectScreen->unk294[1].field1], 1);
+        StartSpriteAffineAnim(&gSprites[sFactorySelectScreen->unk294[0].field1], 1);
+        StartSpriteAffineAnim(&gSprites[sFactorySelectScreen->unk294[2].field1], 1);
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        DestroyTask(taskId);
+        break;
+    case 0:
+        task->data[3] = 16;
+        task->data[24] = 224; // BUG: writing outside the array's bounds.
+        task->data[5] = 32;
+        task->data[8] = 96;
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        SetGpuReg(REG_OFFSET_WIN0H, WINHV_COORDS(task->data[3], task->data[24]));
+        SetGpuReg(REG_OFFSET_WIN0V, WINHV_COORDS(task->data[5], task->data[8]));
+        SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_CLR | WININ_WIN0_OBJ);
+        SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_CLR | WINOUT_WIN01_OBJ);
+        task->data[0]++;
+        break;
+    case 1:
+        task->data[5] += 4;
+        task->data[8] -= 4;
+        if (task->data[5] >= 64 || task->data[8] <= 65)
+        {
+            task->data[5] = 64;
+            task->data[8] = 65;
+        }
+        SetGpuReg(REG_OFFSET_WIN0V, WINHV_COORDS(task->data[5], task->data[8]));
+        if (task->data[5] == 64)
+            task->data[0]++;
+        break;
+    }
+}
+
+static void sub_819C4B4(void)
+{
+    sFactorySelectScreen->unk294[1].field1 = CreateSprite(&gUnknown_08610638, 120, 64, 1);
+    sFactorySelectScreen->unk294[0].field1 = CreateSprite(&gUnknown_08610638,  44, 64, 1);
+    sFactorySelectScreen->unk294[2].field1 = CreateSprite(&gUnknown_08610638, 196, 64, 1);
+
+    gSprites[sFactorySelectScreen->unk294[1].field1].callback = sub_819C040;
+    gSprites[sFactorySelectScreen->unk294[0].field1].callback = SpriteCallbackDummy;
+    gSprites[sFactorySelectScreen->unk294[2].field1].callback = SpriteCallbackDummy;
+
+    sFactorySelectScreen->unk2A0 = TRUE;
+}
+
+static void sub_819C568(void)
+{
+    u8 taskId;
+
+    FreeAndDestroyMonPicSprite(sFactorySelectScreen->unk294[0].field0);
+    FreeAndDestroyMonPicSprite(sFactorySelectScreen->unk294[1].field0);
+    FreeAndDestroyMonPicSprite(sFactorySelectScreen->unk294[2].field0);
+
+    taskId = CreateTask(sub_819C2D4, 1);
+    gTasks[taskId].func(taskId);
+
+    sFactorySelectScreen->unk2A0 = TRUE;
+}
+
+static void Select_SetWinRegs(s16 mWin0H, s16 nWin0H, s16 mWin0V, s16 nWin0V)
+{
+    SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+    SetGpuReg(REG_OFFSET_WIN0H, WINHV_COORDS(mWin0H, nWin0H));
+    SetGpuReg(REG_OFFSET_WIN0V, WINHV_COORDS(mWin0V, nWin0V));
+    SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_CLR | WININ_WIN0_OBJ);
+    SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_CLR | WINOUT_WIN01_OBJ);
+}
+
+static bool32 Select_AreSpeciesValid(u16 monSetId)
+{
+    u8 i, j;
+    u32 species = gFacilityTrainerMons[monSetId].species;
+    u8 selectState = sFactorySelectScreen->selectingMonsState;
+
+    for (i = 1; i < selectState; i++)
+    {
+        for (j = 0; j < SELECTABLE_MONS_COUNT; j++)
+        {
+            if (sFactorySelectScreen->mons[j].selectedId == i)
+            {
+                if (gFacilityTrainerMons[sFactorySelectScreen->mons[j].monSetId].species == species)
+                    return FALSE;
+
+                break;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+static void Task_SelectFadeSpeciesName(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        sFactorySelectScreen->unk2A7 = 0;
+        sFactorySelectScreen->unk2A8 = 0;
+        sFactorySelectScreen->unk2A6 = TRUE;
+        gTasks[taskId].data[0] = 1;
+        break;
+    case 1:
+        if (sFactorySelectScreen->unk2A2)
+        {
+            if (sFactorySelectScreen->unk2A9)
+            {
+                gTasks[taskId].data[0] = 2;
+            }
+            else
+            {
+                sFactorySelectScreen->unk2A7++;
+                if (sFactorySelectScreen->unk2A7 > 6)
+                {
+                    sFactorySelectScreen->unk2A7 = 0;
+                    if (!sFactorySelectScreen->unk2A6)
+                        sFactorySelectScreen->unk2A8--;
+                    else
+                        sFactorySelectScreen->unk2A8++;
+                }
+                BlendPalettes(0x4000, sFactorySelectScreen->unk2A8, 0);
+                if (sFactorySelectScreen->unk2A8 > 5)
+                {
+                    sFactorySelectScreen->unk2A6 = FALSE;
+                }
+                else if (sFactorySelectScreen->unk2A8 == 0)
+                {
+                    gTasks[taskId].data[0] = 2;
+                    sFactorySelectScreen->unk2A6 = TRUE;
+                }
+            }
+        }
+        break;
+    case 2:
+        if (sFactorySelectScreen->unk2A9 > 14)
+        {
+            sFactorySelectScreen->unk2A9 = 0;
+            gTasks[taskId].data[0] = 1;
+        }
+        else
+        {
+            sFactorySelectScreen->unk2A9++;
+        }
+        break;
+    }
+}
+
+// Swap Screen's section begins here.
+
+void Swap_CB2(void)
+{
+    AnimateSprites();
+    BuildOamBuffer();
+    RunTextPrinters();
+    UpdatePaletteFade();
+    RunTasks();
+}
+
+void Swap_VblankCb(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void CopySwappedMonData(void)
+{
+    u8 happiness;
+
+    gPlayerParty[sFactorySwapScreen->playerMonId] = gEnemyParty[sFactorySwapScreen->enemyMonId];
+    happiness = 0;
+    SetMonData(&gPlayerParty[sFactorySwapScreen->playerMonId], MON_DATA_FRIENDSHIP, &happiness);
+    gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->playerMonId].monId = gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->enemyMonId + 3].monId;
+    gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->playerMonId].ivs = gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->enemyMonId + 3].ivs;
+    gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->playerMonId].personality = GetMonData(&gEnemyParty[sFactorySwapScreen->enemyMonId], MON_DATA_PERSONALITY, NULL);
+    gSaveBlock2Ptr->frontier.field_E70[sFactorySwapScreen->playerMonId].abilityBit = GetBoxMonData(&gEnemyParty[sFactorySwapScreen->enemyMonId].box, MON_DATA_ALT_ABILITY, NULL);
+}
+
+void Task_FromSwapScreenToSummaryScreen(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 6:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0);
+        gTasks[taskId].data[0] = 7;
+        break;
+    case 7:
+        if (!gPaletteFade.active)
+        {
+            DestroyTask(sFactorySwapScreen->fadeSpeciesNameTaskId);
+            sub_819F444(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30);
+            Swap_DestroyAllSprites();
+            FREE_AND_SET_NULL(gUnknown_0203CE40);
+            FREE_AND_SET_NULL(gUnknown_0203CE44);
+            FREE_AND_SET_NULL(gUnknown_0203CE48);
+            FREE_AND_SET_NULL(gUnknown_0203CE4C);
+            FreeAllWindowBuffers();
+            gTasks[taskId].data[0] = 8;
+        }
+        break;
+    case 8:
+        DestroyTask(taskId);
+        sFactorySwapScreen->fromSummaryScreen = TRUE;
+        sFactorySwapScreen->unk24 = gPlttBufferUnfaded[244];
+        ShowPokemonSummaryScreen(0, gPlayerParty, sFactorySwapScreen->cursorPos, 3 - 1, CB2_InitSwapScreen);
+        break;
+    }
+}
+
+void Task_CloseSwapScreen(u8 taskId)
+{
+    if (sFactorySwapScreen->unk30 != TRUE)
+    {
+        switch (gTasks[taskId].data[0])
+        {
+        case 0:
+            if (sFactorySwapScreen->monSwapped == TRUE)
+            {
+                gTasks[taskId].data[0]++;
+                gSpecialVar_Result = 0;
+            }
+            else
+            {
+                gTasks[taskId].data[0] = 2;
+                gSpecialVar_Result = 1;
+            }
+            break;
+        case 1:
+            if (sFactorySwapScreen->monSwapped == TRUE)
+            {
+                sFactorySwapScreen->enemyMonId = sFactorySwapScreen->cursorPos;
+                CopySwappedMonData();
+            }
+            gTasks[taskId].data[0]++;
+            break;
+        case 2:
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0);
+            gTasks[taskId].data[0]++;
+            break;
+        case 3:
+            if (!UpdatePaletteFade())
+            {
+                DestroyTask(sFactorySwapScreen->fadeSpeciesNameTaskId);
+                Swap_DestroyAllSprites();
+                FREE_AND_SET_NULL(gUnknown_0203CE40);
+                FREE_AND_SET_NULL(gUnknown_0203CE44);
+                FREE_AND_SET_NULL(gUnknown_0203CE48);
+                FREE_AND_SET_NULL(gUnknown_0203CE4C);
+                FREE_AND_SET_NULL(sFactorySwapScreen);
+                FreeAllWindowBuffers();
+                SetMainCallback2(CB2_ReturnToFieldContinueScript);
+                DestroyTask(taskId);
+            }
+            break;
+        }
+    }
+}
+
+void Task_HandleSwapScreenYesNo(u8 taskId)
+{
+    u16 loPtr, hiPtr;
+
+    if (sFactorySwapScreen->unk30 != TRUE)
+    {
+        switch (gTasks[taskId].data[0])
+        {
+        case 4:
+            Swap_ShowYesNoOptions();
+            gTasks[taskId].data[0] = 5;
+            break;
+        case 5:
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                if (sFactorySwapScreen->yesNoCursorPos == 0)
+                {
+                    gTasks[taskId].data[1] = 1;
+                    hiPtr = gTasks[taskId].data[6];
+                    loPtr = gTasks[taskId].data[7];
+                    gTasks[taskId].func = (void*)((hiPtr << 16) | loPtr);
+                }
+                else
+                {
+                    gTasks[taskId].data[1] = 0;
+                    sub_819EA64(4);
+                    hiPtr = gTasks[taskId].data[6];
+                    loPtr = gTasks[taskId].data[7];
+                    gTasks[taskId].func = (void*)((hiPtr << 16) | loPtr);
+                }
+            }
+            else if (gMain.newKeys & B_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                gTasks[taskId].data[1] = 0;
+                sub_819EA64(4);
+                hiPtr = gTasks[taskId].data[6];
+                loPtr = gTasks[taskId].data[7];
+                gTasks[taskId].func = (void*)((hiPtr << 16) | loPtr);
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_UP)
+            {
+                PlaySE(SE_SELECT);
+                Swap_UpdateYesNoCursorPosition(-1);
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_DOWN)
+            {
+                PlaySE(SE_SELECT);
+                Swap_UpdateYesNoCursorPosition(1);
+            }
+            break;
+        }
+    }
+}
+
+void sub_819CBDC(u8 taskId)
+{
+    if (gTasks[taskId].data[1] == 1)
+    {
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].func = Task_CloseSwapScreen;
+    }
+    else
+    {
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenChooseMons) >> 16;
+        gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenChooseMons);
+        gTasks[taskId].data[5] = 1;
+        gTasks[taskId].func = sub_819D770;
+    }
+}
+
+void sub_819CC24(u8 taskId)
+{
+    if (gTasks[taskId].data[0] == 0)
+    {
+        Swap_PrintOnInfoWindow(gText_QuitSwapping);
+        sFactorySwapScreen->monSwapped = FALSE;
+        gTasks[taskId].data[0] = 4;
+        gTasks[taskId].data[6] = (u32)(sub_819CBDC) >> 16;
+        gTasks[taskId].data[7] = (u32)(sub_819CBDC);
+        gTasks[taskId].func = Task_HandleSwapScreenYesNo;
+    }
+}
+
+void sub_819CC74(u8 taskId)
+{
+    sub_819F3F8(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30, TRUE);
+    if (gTasks[taskId].data[1] == 1)
+    {
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].func = Task_CloseSwapScreen;
+    }
+    else
+    {
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenChooseMons) >> 16;
+        gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenChooseMons);
+        gTasks[taskId].data[5] = 1;
+        gTasks[taskId].func = sub_819D770;
+    }
+}
+
+void sub_819CCD4(u8 taskId)
+{
+    if (gTasks[taskId].data[0] == 0)
+    {
+        sub_819F2B4(&sFactorySwapScreen->unk2C.field1, &sFactorySwapScreen->unk30, TRUE);
+        Swap_PrintOnInfoWindow(gText_AcceptThisPkmn);
+        sFactorySwapScreen->monSwapped = TRUE;
+        gTasks[taskId].data[0] = 4;
+        gTasks[taskId].data[6] = (u32)(sub_819CC74) >> 16;
+        gTasks[taskId].data[7] = (u32)(sub_819CC74);
+        gTasks[taskId].func = Task_HandleSwapScreenYesNo;
+    }
+}
+
+void Task_HandleSwapScreenMenu(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 2:
+        if (!sFactorySwapScreen->fromSummaryScreen)
+            sub_819F2B4(&sFactorySwapScreen->unk2C.field1, &sFactorySwapScreen->unk30, TRUE);
+        gTasks[taskId].data[0] = 9;
+        break;
+    case 9:
+        if (sFactorySwapScreen->unk30 != TRUE)
+        {
+            Swap_ShowMenuOptions();
+            gTasks[taskId].data[0] = 3;
+        }
+        break;
+    case 3:
+        if (sFactorySwapScreen->unk30 != TRUE)
+        {
+            if (gMain.newKeys & A_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                Swap_RunMenuOptionFunc(taskId);
+            }
+            else if (gMain.newKeys & B_BUTTON)
+            {
+                PlaySE(SE_SELECT);
+                sub_819F3F8(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30, TRUE);
+                sub_819EA64(3);
+                gTasks[taskId].data[0] = 0;
+                gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenChooseMons) >> 16;
+                gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenChooseMons);
+                gTasks[taskId].data[5] = 1;
+                gTasks[taskId].func = sub_819D770;
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_UP)
+            {
+                Swap_UpdateMenuCursorPosition(-1);
+            }
+            else if (gMain.newAndRepeatedKeys & DPAD_DOWN)
+            {
+                Swap_UpdateMenuCursorPosition(1);
+            }
+        }
+        break;
+    }
+}
+
+void Task_HandleSwapScreenChooseMons(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        if (!gPaletteFade.active)
+        {
+            sFactorySwapScreen->unk22 = 1;
+            gTasks[taskId].data[0] = 1;
+        }
+        break;
+    case 1:
+        if (gMain.newKeys & A_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sFactorySwapScreen->unk22 = 0;
+            Swap_PrintMonSpecies2();
+            sub_819EAC0();
+            Swap_RunActionFunc(taskId);
+        }
+        else if (gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sFactorySwapScreen->unk22 = 0;
+            Swap_PrintMonSpecies2();
+            sub_819EAC0();
+            gTasks[taskId].data[6] = (u32)(sub_819CC24) >> 16;
+            gTasks[taskId].data[7] = (u32)(sub_819CC24);
+            gTasks[taskId].data[0] = 0;
+            gTasks[taskId].data[5] = 0;
+            gTasks[taskId].func = sub_819D588;
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_LEFT)
+        {
+            Swap_UpdateBallCursorPosition(-1);
+            Swap_PrintMonCategory();
+            Swap_PrintMonSpecies();
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_RIGHT)
+        {
+            Swap_UpdateBallCursorPosition(1);
+            Swap_PrintMonCategory();
+            Swap_PrintMonSpecies();
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_DOWN)
+        {
+            Swap_UpdateActionCursorPosition(1);
+            Swap_PrintMonCategory();
+            Swap_PrintMonSpecies();
+        }
+        else if (gMain.newAndRepeatedKeys & DPAD_UP)
+        {
+            Swap_UpdateActionCursorPosition(-1);
+            Swap_PrintMonCategory();
+            Swap_PrintMonSpecies();
+        }
+        break;
+    }
+}
+
+void Task_SwapFadeSpeciesName(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        sFactorySwapScreen->unk27 = 0;
+        sFactorySwapScreen->unk28 = 0;
+        sFactorySwapScreen->unk26 = TRUE;
+        gTasks[taskId].data[0] = 1;
+        break;
+    case 1:
+        if (sFactorySwapScreen->unk22)
+        {
+            if (sFactorySwapScreen->unk29)
+            {
+                gTasks[taskId].data[0] = 2;
+            }
+            else
+            {
+                sFactorySwapScreen->unk27++;
+                if (sFactorySwapScreen->unk27 > 6)
+                {
+                    sFactorySwapScreen->unk27 = 0;
+                    if (!sFactorySwapScreen->unk26)
+                        sFactorySwapScreen->unk28--;
+                    else
+                        sFactorySwapScreen->unk28++;
+                }
+                BlendPalettes(0x4000, sFactorySwapScreen->unk28, 0);
+                if (sFactorySwapScreen->unk28 > 5)
+                {
+                    sFactorySwapScreen->unk26 = FALSE;
+                }
+                else if (sFactorySwapScreen->unk28 == 0)
+                {
+                    gTasks[taskId].data[0] = 2;
+                    sFactorySwapScreen->unk26 = TRUE;
+                }
+            }
+        }
+        break;
+    case 2:
+        if (sFactorySwapScreen->unk29 > 14)
+        {
+            sFactorySwapScreen->unk29 = 0;
+            gTasks[taskId].data[0] = 1;
+        }
+        else
+        {
+            sFactorySwapScreen->unk29++;
+        }
+        break;
+    }
+}
+
+void Task_SwapFadeSpeciesName2(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        sFactorySwapScreen->unk27 = 0;
+        gTasks[taskId].data[4] = 0;
+        gTasks[taskId].data[0]++;
+        break;
+    case 1:
+        LoadPalette(&gPlttBufferUnfaded[0xF0], 0xE0, 0xA);
+        gTasks[taskId].data[0]++;
+        break;
+    case 2:
+        if (sFactorySwapScreen->unk28 > 15)
+        {
+            gTasks[taskId].data[4] = 1;
+            gTasks[taskId].data[0]++;
+        }
+        sFactorySwapScreen->unk27++;
+        if (sFactorySwapScreen->unk27 > 3)
+        {
+            sFactorySwapScreen->unk27 = 0;
+            gPlttBufferUnfaded[244] = gPlttBufferFaded[228];
+            sFactorySwapScreen->unk28++;
+        }
+        BlendPalettes(0x4000, sFactorySwapScreen->unk28, 0);
+        break;
+    }
+}
+
+void sub_819D12C(u8 taskId)
+{
+    s8 i;
+    u8 var_2C;
+    bool8 r7;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        gTasks[taskId].data[1] = 0;
+        gTasks[taskId].data[2] = 0;
+        gTasks[taskId].data[3] = 0;
+        gTasks[taskId].data[0] = 1;
+        break;
+    case 1:
+        var_2C = 0;
+        for (i = 2; i >= 0; i--)
+        {
+            if (i != 2)
+            {
+                u8 posX = var_2C - gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x;
+                if (posX == 16 || gTasks[taskId].data[i + 2] == 1)
+                {
+                    var_2C = gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x;
+                    gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x += 10;
+                }
+                else if (posX > 16)
+                {
+                    gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x = gSprites[sFactorySwapScreen->ballSpriteIds[i + 1]].pos1.x - 48;
+                }
+            }
+            else
+            {
+                var_2C = gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x;
+                gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x += 10;
+            }
+
+            if (gTasks[taskId].data[i + 1] == 1)
+            {
+                if (gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x > (i * 48) + 72)
+                {
+                    gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x = (i * 48) + 72;
+                    r7 = TRUE;
+                }
+                else if (gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x == (i * 48) + 72)
+                {
+                    r7 = TRUE;
+                }
+                else
+                {
+                    r7 = FALSE;
+                }
+            }
+            else
+            {
+                r7 = FALSE;
+            }
+
+            if (gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x - 16 > 240)
+            {
+                var_2C = gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x;
+                gSprites[sFactorySwapScreen->ballSpriteIds[i]].pos1.x = -16;
+                if (sFactorySwapScreen->inEnemyScreen == TRUE)
+                    gSprites[sFactorySwapScreen->ballSpriteIds[i]].oam.paletteNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_SELECTED);
+                else
+                    gSprites[sFactorySwapScreen->ballSpriteIds[i]].oam.paletteNum = IndexOfSpritePaletteTag(TAG_PAL_BALL_GREY);
+
+                gTasks[taskId].data[i + 1] = 1;
+            }
+        }
+        if (r7 == TRUE)
+            DestroyTask(taskId);
+        break;
+    }
+}
+
+void sub_819D324(u8 taskId)
+{
+    u8 i, j;
+    s32 posX = 0;
+    s8 r4 = gTasks[taskId].data[3];
+    bool8 r1;
+    s16 currPosX;
+    u8 taskId2;
+
+    if (gTasks[taskId].data[2] == 1)
+        r4 *= -1;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        currPosX = gSprites[sFactorySwapScreen->unk8[0][0]].pos1.x;
+        if (!gTasks[taskId].data[2])
+        {
+            if (currPosX + r4 < 240)
+            {
+                r1 = TRUE;
+            }
+            else
+            {
+                r1 = FALSE;
+                posX = 240;
+            }
+        }
+        else
+        {
+            if (currPosX + r4 > 160)
+            {
+                r1 = TRUE;
+            }
+            else
+            {
+                r1 = FALSE;
+                posX = 160;
+            }
+        }
+
+        if (r1 == TRUE)
+        {
+            for (i = 0; i < 3; i++)
+            {
+                for (j = 0; j < 2; j++)
+                    gSprites[sFactorySwapScreen->unk8[j][i]].pos1.x += r4;
+            }
+        }
+        else
+        {
+            for (j = 0; j < 2; j++)
+            {
+                gSprites[sFactorySwapScreen->unk8[j][0]].pos1.x = posX;
+                gSprites[sFactorySwapScreen->unk8[j][1]].pos1.x = posX + 16;
+                gSprites[sFactorySwapScreen->unk8[j][2]].pos1.x = posX + 48;
+            }
+            taskId2 = gTasks[taskId].data[1];
+            gTasks[taskId2].data[3] = 1;
+            DestroyTask(taskId);
+        }
+        break;
+    case 1:
+        currPosX = gSprites[sFactorySwapScreen->unkE[0][0]].pos1.x;
+        if (!gTasks[taskId].data[2])
+        {
+            if (currPosX + r4 < 240)
+            {
+                r1 = TRUE;
+            }
+            else
+            {
+                r1 = FALSE;
+                posX = 240;
+            }
+        }
+        else
+        {
+            if (currPosX + r4 > 192)
+            {
+                r1 = TRUE;
+            }
+            else
+            {
+                r1 = FALSE;
+                posX = 192;
+            }
+        }
+
+        if (r1 == TRUE)
+        {
+            for (i = 0; i < 2; i++)
+            {
+                for (j = 0; j < 2; j++)
+                    gSprites[sFactorySwapScreen->unkE[j][i]].pos1.x += r4;
+            }
+        }
+        else
+        {
+            for (j = 0; j < 2; j++)
+            {
+                gSprites[sFactorySwapScreen->unkE[j][0]].pos1.x = posX;
+                gSprites[sFactorySwapScreen->unkE[j][1]].pos1.x = posX + 16;
+            }
+            taskId2 = gTasks[taskId].data[1];
+            gTasks[taskId2].data[4] = 1;
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+void sub_819D588(u8 taskId)
+{
+    u8 anotherTaskId;
+    u16 loPtr, hiPtr;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        LoadPalette(gUnknown_08610918, 0xE0, 0xA);
+        Swap_PrintActionStrings();
+        PutWindowTilemap(5);
+        gTasks[taskId].data[0]++;
+        break;
+    case 1:
+        sub_819EA64(3);
+        gTasks[taskId].data[0]++;
+        break;
+    case 2:
+        BeginNormalPaletteFade(0x4000, 0, 0, 0x10, gUnknown_0860F13C[37]);
+        gTasks[taskId].data[0]++;
+        break;
+    case 3:
+        if (!gPaletteFade.active)
+        {
+            FillWindowPixelBuffer(5, 0);
+            CopyWindowToVram(5, 2);
+            if (sFactorySwapScreen->inEnemyScreen == TRUE)
+            {
+                anotherTaskId = CreateTask(sub_819D324, 0);
+                gTasks[taskId].data[3] = 0;
+                gTasks[anotherTaskId].data[1] = taskId;
+                gTasks[anotherTaskId].data[0] = 0;
+                gTasks[anotherTaskId].data[2] = 0;
+                gTasks[anotherTaskId].data[3] = 6;
+                gTasks[taskId].data[2] = 5;
+                gTasks[taskId].data[0]++;
+            }
+            else
+            {
+                anotherTaskId = CreateTask(sub_819D324, 0);
+                gTasks[taskId].data[3] = 1;
+                gTasks[taskId].data[4] = 0;
+                gTasks[anotherTaskId].data[1] = taskId;
+                gTasks[anotherTaskId].data[0] = 1;
+                gTasks[anotherTaskId].data[2] = 0;
+                gTasks[anotherTaskId].data[3] = 6;
+                gTasks[taskId].data[0] += 2;
+            }
+        }
+        break;
+    case 4:
+        if (gTasks[taskId].data[2] == 0)
+        {
+            anotherTaskId = CreateTask(sub_819D324, 0);
+            gTasks[taskId].data[4] = 0;
+            gTasks[anotherTaskId].data[1] = taskId;
+            gTasks[anotherTaskId].data[0] = 1;
+            gTasks[anotherTaskId].data[2] = 0;
+            gTasks[anotherTaskId].data[3] = 6;
+            gTasks[taskId].data[0]++;
+        }
+        else
+        {
+            gTasks[taskId].data[2]--;
+        }
+        break;
+    case 5:
+        if (gTasks[taskId].data[3] == 1 && gTasks[taskId].data[4] == 1)
+        {
+            gTasks[taskId].data[0] = gTasks[taskId].data[5];
+            loPtr = gTasks[taskId].data[6];
+            hiPtr = gTasks[taskId].data[7];
+            gTasks[taskId].func = (void *)((loPtr << 0x10) | (hiPtr));
+        }
+        break;
+    }
+}
+
+void sub_819D770(u8 taskId)
+{
+    u8 anotherTaskId;
+    u16 loPtr, hiPtr;
+    if (sFactorySwapScreen->unk30 == TRUE)
+        return;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        if (sFactorySwapScreen->inEnemyScreen == TRUE)
+        {
+            anotherTaskId = CreateTask(sub_819D324, 0);
+            gTasks[taskId].data[3] = 0;
+            gTasks[anotherTaskId].data[1] = taskId;
+            gTasks[anotherTaskId].data[0] = 0;
+            gTasks[anotherTaskId].data[2] = 1;
+            gTasks[anotherTaskId].data[3] = 6;
+            gTasks[taskId].data[2] = 10;
+            gTasks[taskId].data[0]++;
+        }
+        else
+        {
+            anotherTaskId = CreateTask(sub_819D324, 0);
+            gTasks[taskId].data[3] = 1;
+            gTasks[taskId].data[4] = 0;
+            gTasks[anotherTaskId].data[1] = taskId;
+            gTasks[anotherTaskId].data[0] = 1;
+            gTasks[anotherTaskId].data[2] = 1;
+            gTasks[anotherTaskId].data[3] = 6;
+            gTasks[taskId].data[0] += 2;
+        }
+        break;
+    case 1:
+        if (gTasks[taskId].data[2] == 0)
+        {
+            anotherTaskId = CreateTask(sub_819D324, 0);
+            gTasks[taskId].data[4] = 0;
+            gTasks[anotherTaskId].data[1] = taskId;
+            gTasks[anotherTaskId].data[0] = 1;
+            gTasks[anotherTaskId].data[2] = 1;
+            gTasks[anotherTaskId].data[3] = 6;
+            gTasks[taskId].data[0]++;
+        }
+        else
+        {
+            gTasks[taskId].data[2]--;
+        }
+        break;
+    case 2:
+        if (gTasks[taskId].data[3] == 1 && gTasks[taskId].data[4] == 1)
+        {
+            gPlttBufferFaded[226] = gUnknown_0860F13C[37];
+            Swap_PrintActionStrings();
+            PutWindowTilemap(5);
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 3:
+        BeginNormalPaletteFade(0x4000, 0, 0x10, 0, gUnknown_0860F13C[37]);
+        gTasks[taskId].data[0]++;
+        break;
+    case 4:
+        if (!gPaletteFade.active)
+        {
+            Swap_PrintOneActionString(0);
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 5:
+        Swap_PrintOneActionString(1);
+        PutWindowTilemap(3);
+        gTasks[taskId].data[0]++;
+        break;
+    case 6:
+        FillWindowPixelBuffer(5, 0);
+        CopyWindowToVram(5, 2);
+        gTasks[taskId].data[0]++;
+        break;
+    case 7:
+        if (!sFactorySwapScreen->inEnemyScreen)
+            Swap_PrintOnInfoWindow(gText_SelectPkmnToSwap);
+        else
+            Swap_PrintOnInfoWindow(gText_SelectPkmnToAccept);
+        if (sFactorySwapScreen->cursorPos < 3)
+            gSprites[sFactorySwapScreen->cursorSpriteId].invisible = 0;
+        Swap_PrintMonCategory();
+        gTasks[taskId].data[0]++;
+        break;
+    case 8:
+        Swap_PrintMonSpecies3();
+        sub_819EADC();
+        sFactorySwapScreen->unk22 = 1;
+        gTasks[taskId].data[0] = gTasks[taskId].data[5];
+        loPtr = gTasks[taskId].data[6];
+        hiPtr = gTasks[taskId].data[7];
+        gTasks[taskId].func = (void *)((loPtr << 0x10) | (hiPtr));
+        break;
+    }
+}
+
+void sub_819D9EC(u8 taskId)
+{
+    u8 i;
+    if (sFactorySwapScreen->unk30 == TRUE)
+        return;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        Swap_PrintMonSpecies3();
+        gTasks[taskId].data[0]++;
+        break;
+    case 1:
+        sub_819EADC();
+        gSprites[sFactorySwapScreen->cursorSpriteId].invisible = 1;
+        gTasks[taskId].data[0]++;
+        break;
+    case 2:
+        CreateTask(sub_819D12C, 0);
+        gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].func = Task_SwapFadeSpeciesName2;
+        gTasks[taskId].data[0]++;
+        break;
+    case 3:
+        if (!FuncIsActiveTask(sub_819D12C) && gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].data[4] == 1)
+        {
+            sub_819EAC0();
+            if (!sFactorySwapScreen->inEnemyScreen)
+            {
+                Swap_InitActions(ACTIONS_ENEMY_SCREEN);
+            }
+            else
+            {
+                Swap_InitActions(ACTIONS_PLAYER_SCREEN);
+                for (i = 0; i < 3; i++)
+                    gSprites[sFactorySwapScreen->unk8[1][i]].invisible = 1;
+            }
+            gSprites[sFactorySwapScreen->cursorSpriteId].pos1.x = gSprites[sFactorySwapScreen->ballSpriteIds[sFactorySwapScreen->cursorPos]].pos1.x;
+            gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].func = Task_SwapFadeSpeciesName;
+            sFactorySwapScreen->unk27 = 0;
+            sFactorySwapScreen->unk28 = 6;
+            sFactorySwapScreen->unk26 = FALSE;
+            gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].data[0] = 1;
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 4:
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenChooseMons) >> 0x10;
+        gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenChooseMons);
+        gTasks[taskId].data[5] = 1;
+        gTasks[taskId].func = sub_819D770;
+        break;
+    }
+}
+
+void Swap_InitStruct(void)
+{
+    if (sFactorySwapScreen == NULL)
+    {
+        sFactorySwapScreen = AllocZeroed(sizeof(*sFactorySwapScreen));
+        sFactorySwapScreen->cursorPos = 0;
+        sFactorySwapScreen->unk30 = FALSE;
+        sFactorySwapScreen->fromSummaryScreen = FALSE;
+    }
+}
+
+void sub_819DC00(void)
+{
+    sFactorySwapScreen = NULL;
+    SetMainCallback2(CB2_InitSwapScreen);
+}
+
+void CB2_InitSwapScreen(void)
+{
+    u8 taskId;
+
+    switch (gMain.state)
+    {
+    case 0:
+        SetHBlankCallback(NULL);
+        SetVBlankCallback(NULL);
+        CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, gUnknown_086108B8, ARRAY_COUNT(gUnknown_086108B8));
+        InitWindows(gUnknown_086108C8);
+        DeactivateAllTextPrinters();
+        gMain.state++;
+        break;
+    case 1:
+        gUnknown_0203CE40 = Alloc(0x440);
+        gUnknown_0203CE44 = AllocZeroed(0x440);
+        gUnknown_0203CE48 = Alloc(0x800);
+        gUnknown_0203CE4C = AllocZeroed(0x800);
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgX(2, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        SetGpuReg(REG_OFFSET_MOSAIC, 0);
+        SetGpuReg(REG_OFFSET_WIN0H, 0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0);
+        SetGpuReg(REG_OFFSET_WIN1H, 0);
+        SetGpuReg(REG_OFFSET_WIN1V, 0);
+        SetGpuReg(REG_OFFSET_WININ, 0);
+        SetGpuReg(REG_OFFSET_WINOUT, 0);
+        gMain.state++;
+        break;
+    case 2:
+        ResetPaletteFade();
+        ResetSpriteData();
+        ResetTasks();
+        FreeAllSpritePalettes();
+        ResetAllPicSprites();
+        CpuCopy16(gFrontierFactorySelectMenu_Gfx, gUnknown_0203CE40, 0x440);
+        CpuCopy16(gUnknown_0861033C, gUnknown_0203CE44, 0x60);
+        LoadBgTiles(1, gUnknown_0203CE40, 0x440, 0);
+        LoadBgTiles(3, gUnknown_0203CE44, 0x60, 0);
+        CpuCopy16(gFrontierFactorySelectMenu_Tilemap, gUnknown_0203CE48, 0x800);
+        LoadBgTilemap(1, gUnknown_0203CE48, 0x800, 0);
+        LoadPalette(gFrontierFactorySelectMenu_Pal, 0, 0x40);
+        LoadPalette(gUnknown_08610918, 0xF0, 10);
+        LoadPalette(gUnknown_08610918, 0xE0, 10);
+        LoadPalette(gUnknown_0861039C, 0x20, 4);
+        gMain.state++;
+        break;
+    case 3:
+        SetBgTilemapBuffer(3, gUnknown_0203CE4C);
+        CopyToBgTilemapBufferRect(3, gUnknown_0861023C, 11, 4, 8, 8);
+        CopyBgTilemapBufferToVram(3);
+        gMain.state++;
+        break;
+    case 4:
+        LoadSpritePalettes(gUnknown_086106B0);
+        LoadSpriteSheets(gUnknown_08610650);
+        LoadCompressedObjectPic(gUnknown_086106A0);
+        SetVBlankCallback(Swap_VblankCb);
+        gMain.state++;
+        break;
+    case 5:
+        if (sFactorySwapScreen->fromSummaryScreen == TRUE)
+            sFactorySwapScreen->cursorPos = gUnknown_0203CF20;
+        gMain.state++;
+        break;
+    case 6:
+        Swap_InitStruct();
+        Swap_InitAllSprites();
+        if (sFactorySwapScreen->fromSummaryScreen == TRUE)
+            Swap_ShowSummaryMonSprite();
+        Swap_InitActions(ACTIONS_PLAYER_SCREEN);
+        gMain.state++;
+        break;
+    case 7:
+        Swap_PrintOnInfoWindow(gText_SelectPkmnToSwap);
+        PutWindowTilemap(2);
+        gMain.state++;
+        break;
+    case 8:
+        Swap_PrintMonCategory();
+        PutWindowTilemap(8);
+        gMain.state++;
+        break;
+    case 9:
+        if (!sFactorySwapScreen->fromSummaryScreen)
+            Swap_PrintMonSpecies();
+        PutWindowTilemap(1);
+        gMain.state++;
+        break;
+    case 10:
+        Swap_PrintPkmnSwap();
+        PutWindowTilemap(0);
+        gMain.state++;
+        break;
+    case 11:
+        gMain.state++;
+        break;
+    case 12:
+        if (sFactorySwapScreen->fromSummaryScreen)
+            Swap_PrintMonSpecies2();
+        gMain.state++;
+        break;
+    case 13:
+        Swap_PrintActionStrings2();
+        PutWindowTilemap(3);
+        gMain.state++;
+        break;
+    case 14:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, 0);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(2);
+        if (sFactorySwapScreen->fromSummaryScreen == TRUE)
+        {
+            ShowBg(3);
+            SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_OBJ);
+            SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4));
+        }
+        else
+        {
+            HideBg(3);
+        }
+        gMain.state++;
+        break;
+    case 15:
+        sFactorySwapScreen->fadeSpeciesNameTaskId = CreateTask(Task_SwapFadeSpeciesName, 0);
+        if (!sFactorySwapScreen->fromSummaryScreen)
+        {
+            gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].data[0] = 0;
+            taskId = CreateTask(Task_HandleSwapScreenChooseMons, 0);
+            gTasks[taskId].data[0] = 0;
+        }
+        else
+        {
+            sub_819EAF8();
+            gTasks[sFactorySwapScreen->fadeSpeciesNameTaskId].data[0] = 1;
+            sFactorySwapScreen->unk22 = FALSE;
+            taskId = CreateTask(Task_HandleSwapScreenMenu, 0);
+            gTasks[taskId].data[0] = 2;
+        }
+        SetMainCallback2(Swap_CB2);
+        break;
+    }
+}
+
+extern const struct SpriteTemplate gUnknown_08610834;
+extern const struct SpriteTemplate gUnknown_0861084C;
+extern const struct SpriteTemplate gUnknown_08610864;
+extern const struct SpriteTemplate gUnknown_0861087C;
+extern const struct SpriteTemplate gUnknown_08610894;
+
+void Swap_InitAllSprites(void)
+{
+    u8 i;
+    u8 x;
+    struct SpriteTemplate spriteTemplate;
+
+    spriteTemplate = gUnknown_08610834;
+    spriteTemplate.paletteTag = TAG_PAL_BALL_SELECTED;
+
+    for (i = 0; i < 3; i++)
+    {
+        sFactorySwapScreen->ballSpriteIds[i] = CreateSprite(&spriteTemplate, (48 * i) + 72, 64, 1);
+        gSprites[sFactorySwapScreen->ballSpriteIds[i]].data[0] = 0;
+    }
+    sFactorySwapScreen->cursorSpriteId = CreateSprite(&gUnknown_0861084C, gSprites[sFactorySwapScreen->ballSpriteIds[sFactorySwapScreen->cursorPos]].pos1.x, 88, 0);
+    sFactorySwapScreen->menuCursor1SpriteId = CreateSprite(&gUnknown_08610864, 176, 112, 0);
+    sFactorySwapScreen->menuCursor2SpriteId = CreateSprite(&gUnknown_0861087C, 176, 144, 0);
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].invisible = 1;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].invisible = 1;
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].centerToCornerVecX = 0;
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].centerToCornerVecY = 0;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].centerToCornerVecX = 0;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].centerToCornerVecY = 0;
+
+    if (sFactorySwapScreen->fromSummaryScreen == TRUE)
+        x = 240;
+    else
+        x = 192;
+
+    spriteTemplate = gUnknown_0861084C;
+    spriteTemplate.tileTag = TAG_TILE_68;
+    sFactorySwapScreen->unk8[0][0] = CreateSprite(&spriteTemplate, 240, 120, 10);
+
+    spriteTemplate = gUnknown_08610864;
+    spriteTemplate.tileTag = TAG_TILE_69;
+    sFactorySwapScreen->unk8[0][1] = CreateSprite(&spriteTemplate, 256, 120, 10);
+    sFactorySwapScreen->unk8[0][2] = CreateSprite(&spriteTemplate, 288, 120, 10);
+
+    spriteTemplate = gUnknown_0861084C;
+    spriteTemplate.tileTag = TAG_TILE_6A;
+    sFactorySwapScreen->unk8[1][0] = CreateSprite(&spriteTemplate, 240, 120, 1);
+
+    spriteTemplate = gUnknown_08610864;
+    spriteTemplate.tileTag = TAG_TILE_6B;
+    sFactorySwapScreen->unk8[1][1] = CreateSprite(&spriteTemplate, 256, 120, 1);
+    spriteTemplate.tileTag = TAG_TILE_6C;
+    sFactorySwapScreen->unk8[1][2] = CreateSprite(&spriteTemplate, 288, 120, 1);
+
+    spriteTemplate = gUnknown_0861084C;
+    spriteTemplate.tileTag = TAG_TILE_68;
+    sFactorySwapScreen->unkE[0][0] = CreateSprite(&spriteTemplate, x, 144, 10);
+
+    spriteTemplate = gUnknown_08610864;
+    spriteTemplate.tileTag = TAG_TILE_69;
+    sFactorySwapScreen->unkE[0][1] = CreateSprite(&spriteTemplate, x + 16, 144, 10);
+
+    spriteTemplate = gUnknown_0861084C;
+    spriteTemplate.tileTag = TAG_TILE_6A;
+    sFactorySwapScreen->unkE[1][0] = CreateSprite(&spriteTemplate, x, 144, 1);
+
+    spriteTemplate = gUnknown_08610864;
+    spriteTemplate.tileTag = TAG_TILE_6C;
+    sFactorySwapScreen->unkE[1][1] = CreateSprite(&spriteTemplate, x + 16, 144, 1);
+
+    for (i = 0; i < 2; i++)
+    {
+        gSprites[sFactorySwapScreen->unk8[i][0]].centerToCornerVecX = 0;
+        gSprites[sFactorySwapScreen->unk8[i][0]].centerToCornerVecY = 0;
+        gSprites[sFactorySwapScreen->unk8[i][1]].centerToCornerVecX = 0;
+        gSprites[sFactorySwapScreen->unk8[i][1]].centerToCornerVecY = 0;
+        gSprites[sFactorySwapScreen->unk8[i][2]].centerToCornerVecX = 0;
+        gSprites[sFactorySwapScreen->unk8[i][2]].centerToCornerVecY = 0;
+        gSprites[sFactorySwapScreen->unkE[i][0]].centerToCornerVecX = 0;
+        gSprites[sFactorySwapScreen->unkE[i][0]].centerToCornerVecY = 0;
+        gSprites[sFactorySwapScreen->unkE[i][1]].centerToCornerVecX = 0;
+        gSprites[sFactorySwapScreen->unkE[i][1]].centerToCornerVecY = 0;
+
+        gSprites[sFactorySwapScreen->unk8[i][0]].invisible = 1;
+        gSprites[sFactorySwapScreen->unk8[i][1]].invisible = 1;
+        gSprites[sFactorySwapScreen->unk8[i][2]].invisible = 1;
+        gSprites[sFactorySwapScreen->unkE[i][0]].invisible = 1;
+        gSprites[sFactorySwapScreen->unkE[i][1]].invisible = 1;
+    }
+
+    gSprites[sFactorySwapScreen->unkE[0][0]].invisible = 0;
+    gSprites[sFactorySwapScreen->unkE[0][1]].invisible = 0;
+    gSprites[sFactorySwapScreen->unk8[0][0]].invisible = 0;
+    gSprites[sFactorySwapScreen->unk8[0][1]].invisible = 0;
+    gSprites[sFactorySwapScreen->unk8[0][2]].invisible = 0;
+}
+
+void Swap_DestroyAllSprites(void)
+{
+    u8 i, j;
+
+    for (i = 0; i < 3; i++)
+        DestroySprite(&gSprites[sFactorySwapScreen->ballSpriteIds[i]]);
+    DestroySprite(&gSprites[sFactorySwapScreen->cursorSpriteId]);
+    DestroySprite(&gSprites[sFactorySwapScreen->menuCursor1SpriteId]);
+    DestroySprite(&gSprites[sFactorySwapScreen->menuCursor2SpriteId]);
+    for (i = 0; i < 2; i++)
+    {
+        for (j = 0; j < 3; j++)
+            DestroySprite(&gSprites[sFactorySwapScreen->unk8[i][j]]);
+    }
+    for (i = 0; i < 2; i++)
+    {
+        for (j = 0; j < 2; j++)
+            DestroySprite(&gSprites[sFactorySwapScreen->unkE[i][j]]);
+    }
+}
+
+void Swap_HandleActionCursorChange(u8 cursorId)
+{
+    if (cursorId < 3)
+    {
+        gSprites[sFactorySwapScreen->cursorSpriteId].invisible = 0;
+        sub_819E8EC();
+        gSprites[sFactorySwapScreen->cursorSpriteId].pos1.x = gSprites[sFactorySwapScreen->ballSpriteIds[cursorId]].pos1.x;
+    }
+    else
+    {
+        gSprites[sFactorySwapScreen->cursorSpriteId].invisible = 1;
+        sub_819E838(sFactorySwapScreen->actionsData[cursorId].id);
+    }
+}
+
+void Swap_UpdateBallCursorPosition(s8 direction)
+{
+    u8 cursorPos;
+    PlaySE(SE_SELECT);
+    if (direction > 0) // Move cursor right.
+    {
+        if (sFactorySwapScreen->cursorPos + 1 != sFactorySwapScreen->actionsCount)
+            sFactorySwapScreen->cursorPos++;
+        else
+            sFactorySwapScreen->cursorPos = 0;
+    }
+    else // Move cursor left.
+    {
+        if (sFactorySwapScreen->cursorPos != 0)
+            sFactorySwapScreen->cursorPos--;
+        else
+            sFactorySwapScreen->cursorPos = sFactorySwapScreen->actionsCount - 1;
+    }
+
+    cursorPos = sFactorySwapScreen->cursorPos;
+    Swap_HandleActionCursorChange(cursorPos);
+}
+
+void Swap_UpdateActionCursorPosition(s8 direction)
+{
+    u8 cursorPos;
+    PlaySE(SE_SELECT);
+    if (direction > 0) // Move cursor down.
+    {
+        if (sFactorySwapScreen->cursorPos < 3)
+            sFactorySwapScreen->cursorPos = 3;
+        else if (sFactorySwapScreen->cursorPos + 1 != sFactorySwapScreen->actionsCount)
+            sFactorySwapScreen->cursorPos++;
+        else
+            sFactorySwapScreen->cursorPos = 0;
+    }
+    else // Move cursor up.
+    {
+        if (sFactorySwapScreen->cursorPos < 3)
+            sFactorySwapScreen->cursorPos = sFactorySwapScreen->actionsCount - 1;
+        else if (sFactorySwapScreen->cursorPos != 0)
+            sFactorySwapScreen->cursorPos--;
+        else
+            sFactorySwapScreen->cursorPos = sFactorySwapScreen->actionsCount - 1;
+    }
+
+    cursorPos = sFactorySwapScreen->cursorPos;
+    Swap_HandleActionCursorChange(cursorPos);
+}
+
+void Swap_UpdateYesNoCursorPosition(s8 direction)
+{
+    if (direction > 0) // Move cursor down.
+    {
+        if (sFactorySwapScreen->yesNoCursorPos != 1)
+            sFactorySwapScreen->yesNoCursorPos++;
+        else
+            sFactorySwapScreen->yesNoCursorPos = 0;
+    }
+    else // Move cursor up.
+    {
+        if (sFactorySwapScreen->yesNoCursorPos != 0)
+            sFactorySwapScreen->yesNoCursorPos--;
+        else
+            sFactorySwapScreen->yesNoCursorPos = 1;
+    }
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.y = (sFactorySwapScreen->yesNoCursorPos * 16) + 112;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.y = (sFactorySwapScreen->yesNoCursorPos * 16) + 112;
+}
+
+void Swap_UpdateMenuCursorPosition(s8 direction)
+{
+    PlaySE(SE_SELECT);
+    if (direction > 0) // Move cursor down.
+    {
+        if (sFactorySwapScreen->menuCursorPos != MENU_OPTIONS_COUNT - 1)
+            sFactorySwapScreen->menuCursorPos++;
+        else
+            sFactorySwapScreen->menuCursorPos = 0;
+    }
+    else // Move cursor up.
+    {
+        if (sFactorySwapScreen->menuCursorPos != 0)
+            sFactorySwapScreen->menuCursorPos--;
+        else
+            sFactorySwapScreen->menuCursorPos = MENU_OPTIONS_COUNT - 1;
+    }
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.y = (sFactorySwapScreen->menuCursorPos * 16) + 112;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.y = (sFactorySwapScreen->menuCursorPos * 16) + 112;
+}
+
+void sub_819E838(u8 arg0)
+{
+    u8 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (arg0 == 2)
+        {
+            gSprites[sFactorySwapScreen->unk8[1][i]].invisible = 0;
+            if (i < 2)
+                gSprites[sFactorySwapScreen->unkE[1][i]].invisible = 1;
+        }
+        else if (arg0 == 3)
+        {
+            if (i < 2)
+                gSprites[sFactorySwapScreen->unkE[1][i]].invisible = 0;
+            gSprites[sFactorySwapScreen->unk8[1][i]].invisible = 1;
+        }
+    }
+}
+
+void sub_819E8EC(void)
+{
+    u8 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        gSprites[sFactorySwapScreen->unk8[1][i]].invisible = 1;
+        if (i < 2)
+            gSprites[sFactorySwapScreen->unkE[1][i]].invisible = 1;
+    }
+}
+
+void Swap_ShowMenuOptions(void)
+{
+    if (sFactorySwapScreen->fromSummaryScreen == TRUE)
+        sFactorySwapScreen->fromSummaryScreen = FALSE;
+    else
+        sFactorySwapScreen->menuCursorPos = 0;
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.x = 176;
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.y = (sFactorySwapScreen->menuCursorPos * 16) + 112;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.x = 208;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.y = (sFactorySwapScreen->menuCursorPos * 16) + 112;
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].invisible = 0;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].invisible = 0;
+
+    Swap_PrintMenuOptions();
+}
+
+void Swap_ShowYesNoOptions(void)
+{
+    sFactorySwapScreen->yesNoCursorPos = 0;
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.x = 176;
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].pos1.y = 112;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.x = 208;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].pos1.y = 112;
+
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].invisible = 0;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].invisible = 0;
+
+    Swap_PrintYesNoOptions();
+}
+
+void sub_819EA64(u8 windowId)
+{
+    gSprites[sFactorySwapScreen->menuCursor1SpriteId].invisible = 1;
+    gSprites[sFactorySwapScreen->menuCursor2SpriteId].invisible = 1;
+    FillWindowPixelBuffer(windowId, 0);
+    CopyWindowToVram(windowId, 2);
+    ClearWindowTilemap(windowId);
+}
+
+void sub_819EAC0(void)
+{
+    PutWindowTilemap(1);
+    FillWindowPixelBuffer(1, 0);
+    CopyWindowToVram(1, 2);
+}
+
+void sub_819EADC(void)
+{
+    PutWindowTilemap(7);
+    FillWindowPixelBuffer(7, 0);
+    CopyWindowToVram(7, 2);
+}
+
+void sub_819EAF8(void)
+{
+    sub_819EAC0();
+    PutWindowTilemap(5);
+    FillWindowPixelBuffer(5, 0);
+    CopyWindowToVram(5, 2);
+}
+
+void Swap_PrintPkmnSwap(void)
+{
+    FillWindowPixelBuffer(0, 0x11);
+    AddTextPrinterParameterized(0, 1, gText_PkmnSwap, 2, 1, 0, NULL);
+    CopyWindowToVram(0, 3);
+}
+
+void Swap_PrintMonSpecies(void)
+{
+    u16 species;
+    u8 x;
+
+    FillWindowPixelBuffer(1, 0);
+    if (sFactorySwapScreen->cursorPos > 2)
+    {
+        CopyWindowToVram(1, 2);
+    }
+    else
+    {
+        u8 monId = sFactorySwapScreen->cursorPos;
+        if (!sFactorySwapScreen->inEnemyScreen)
+            species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, NULL);
+        else
+            species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, NULL);
+        StringCopy(gStringVar4, gSpeciesNames[species]);
+        x = GetStringRightAlignXOffset(1, gStringVar4, 86);
+        AddTextPrinterParameterized3(1, 1, x, 1, gUnknown_08610925, 0, gStringVar4);
+        CopyWindowToVram(1, 3);
+    }
+}
+
+void Swap_PrintOnInfoWindow(const u8 *str)
+{
+    FillWindowPixelBuffer(2, 0);
+    AddTextPrinterParameterized(2, 1, str, 2, 5, 0, NULL);
+    CopyWindowToVram(2, 2);
+}
+
+void Swap_PrintMenuOptions(void)
+{
+    PutWindowTilemap(3);
+    FillWindowPixelBuffer(3, 0);
+    AddTextPrinterParameterized3(3, 1, 15,  1, gUnknown_08610922, 0, gText_Summary2);
+    AddTextPrinterParameterized3(3, 1, 15, 17, gUnknown_08610922, 0, gText_Swap);
+    AddTextPrinterParameterized3(3, 1, 15, 33, gUnknown_08610922, 0, gText_Rechoose);
+    CopyWindowToVram(3, 3);
+}
+
+void Swap_PrintYesNoOptions(void)
+{
+    PutWindowTilemap(4);
+    FillWindowPixelBuffer(4, 0);
+    AddTextPrinterParameterized3(4, 1, 7, 1,  gUnknown_08610922, 0, gText_Yes3);
+    AddTextPrinterParameterized3(4, 1, 7, 17, gUnknown_08610922, 0, gText_No3);
+    CopyWindowToVram(4, 3);
+}
+
+void Swap_PrintActionString(const u8 *str, u32 y, u32 windowId)
+{
+    s32 x = GetStringRightAlignXOffset(0, str, 0x46);
+    AddTextPrinterParameterized3(windowId, 0, x, y, gUnknown_08610922, 0, str);
+}
+
+void Swap_PrintActionStrings(void)
+{
+    FillWindowPixelBuffer(5, 0);
+    switch (sFactorySwapScreen->inEnemyScreen)
+    {
+    case TRUE:
+        Swap_PrintActionString(gText_PkmnForSwap, 0, 5);
+    case FALSE:
+        Swap_PrintActionString(gText_Cancel3, 24, 5);
+        break;
+    }
+    CopyWindowToVram(5, 3);
+}
+
+void Swap_PrintActionStrings2(void)
+{
+    FillWindowPixelBuffer(3, 0);
+    switch (sFactorySwapScreen->inEnemyScreen)
+    {
+    case TRUE:
+        Swap_PrintActionString(gText_PkmnForSwap, 8, 3);
+    case FALSE:
+        Swap_PrintActionString(gText_Cancel3, 32, 3);
+        break;
+    }
+    CopyWindowToVram(3, 3);
+}
+
+void Swap_PrintOneActionString(u8 which)
+{
+    switch (which)
+    {
+    case 0:
+        if (sFactorySwapScreen->inEnemyScreen == TRUE)
+            Swap_PrintActionString(gText_PkmnForSwap, 8, 3);
+        break;
+    case 1:
+        Swap_PrintActionString(gText_Cancel3, 32, 3);
+        break;
+    }
+    CopyWindowToVram(3, 3);
+}
+
+void Swap_PrintMonSpecies2(void)
+{
+    u16 species;
+    u8 x;
+    u16 pal[5];
+
+    CpuCopy16(gUnknown_08610918, pal, 8);
+    if (!sFactorySwapScreen->fromSummaryScreen)
+        pal[4] = gPlttBufferFaded[228];
+    else
+        pal[4] = sFactorySwapScreen->unk24;
+    LoadPalette(pal, 0xF0, 0xA);
+
+    PutWindowTilemap(7);
+    FillWindowPixelBuffer(7, 0);
+    if (sFactorySwapScreen->cursorPos > 2)
+    {
+        CopyWindowToVram(7, 3);
+    }
+    else
+    {
+        u8 monId = sFactorySwapScreen->cursorPos;
+        if (!sFactorySwapScreen->inEnemyScreen)
+            species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, NULL);
+        else
+            species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, NULL);
+        StringCopy(gStringVar4, gSpeciesNames[species]);
+        x = GetStringRightAlignXOffset(1, gStringVar4, 86);
+        AddTextPrinterParameterized3(7, 1, x, 1, gUnknown_08610925, 0, gStringVar4);
+        CopyWindowToVram(7, 3);
+    }
+}
+
+void Swap_PrintMonSpecies3(void)
+{
+    u16 species;
+    u8 x;
+
+    LoadPalette(gUnknown_08610918, 0xE0, 0xA);
+    CpuCopy16(gPlttBufferUnfaded + 240, gPlttBufferFaded + 224, 10);
+
+    if (sFactorySwapScreen->cursorPos > 2)
+    {
+        CopyWindowToVram(1, 2);
+    }
+    else
+    {
+        u8 monId = sFactorySwapScreen->cursorPos;
+        if (!sFactorySwapScreen->inEnemyScreen)
+            species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, NULL);
+        else
+            species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, NULL);
+        StringCopy(gStringVar4, gSpeciesNames[species]);
+        x = GetStringRightAlignXOffset(1, gStringVar4, 86);
+        AddTextPrinterParameterized3(1, 1, x, 1, gUnknown_08610925, 0, gStringVar4);
+        CopyWindowToVram(1, 3);
+    }
+}
+
+void Swap_PrintMonCategory(void)
+{
+    u16 species;
+    u8 text[30];
+    u8 x;
+    u8 monId = sFactorySwapScreen->cursorPos;
+
+    FillWindowPixelBuffer(8, 0);
+    if (monId > 2)
+    {
+        CopyWindowToVram(8, 2);
+    }
+    else
+    {
+        PutWindowTilemap(8);
+        if (!sFactorySwapScreen->inEnemyScreen)
+            species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, NULL);
+        else
+            species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, NULL);
+        CopyMonCategoryText(SpeciesToNationalPokedexNum(species), text);
+        x = GetStringRightAlignXOffset(1, text, 0x76);
+        AddTextPrinterParameterized(8, 1, text, x, 1, 0, NULL);
+        CopyWindowToVram(8, 2);
+    }
+}
+
+extern const struct SwapActionIdAndFunc gUnknown_08610928[4];
+extern const struct SwapActionIdAndFunc gUnknown_08610948[5];
+
+void Swap_InitActions(u8 id)
+{
+    if (sFactorySwapScreen->fromSummaryScreen != TRUE)
+    {
+        switch (id)
+        {
+        case ACTIONS_PLAYER_SCREEN:
+            sFactorySwapScreen->inEnemyScreen = FALSE;
+            sFactorySwapScreen->cursorPos = 0;
+            sFactorySwapScreen->actionsCount = ARRAY_COUNT(gUnknown_08610928);
+            sFactorySwapScreen->actionsData = gUnknown_08610928;
+            break;
+        case ACTIONS_ENEMY_SCREEN:
+            sFactorySwapScreen->inEnemyScreen = TRUE;
+            sFactorySwapScreen->cursorPos = 0;
+            sFactorySwapScreen->actionsCount = ARRAY_COUNT(gUnknown_08610948);
+            sFactorySwapScreen->actionsData = gUnknown_08610948;
+            break;
+        }
+    }
+}
+
+void Swap_RunMenuOptionFunc(u8 taskId)
+{
+    gUnknown_03001280 = sSwap_MenuOptionFuncs[sFactorySwapScreen->menuCursorPos];
+    gUnknown_03001280(taskId);
+}
+
+void sub_819F0CC(u8 taskId)
+{
+    sub_819F3F8(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30, TRUE);
+    sFactorySwapScreen->playerMonId = sFactorySwapScreen->cursorPos;
+    sub_819EA64(3);
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].func = sub_819D9EC;
+}
+
+void sub_819F114(u8 taskId)
+{
+    gTasks[taskId].data[0] = 6;
+    gTasks[taskId].func = Task_FromSwapScreenToSummaryScreen;
+}
+
+void sub_819F134(u8 taskId)
+{
+    sub_819F3F8(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30, TRUE);
+    sub_819EA64(3);
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenChooseMons) >> 0x10;
+    gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenChooseMons);
+    gTasks[taskId].data[5] = 1;
+    gTasks[taskId].func = sub_819D770;
+}
+
+void Swap_RunActionFunc(u8 taskId)
+{
+    gUnknown_03001280 = sFactorySwapScreen->actionsData[sFactorySwapScreen->cursorPos].func;
+    gUnknown_03001280(taskId);
+}
+
+void sub_819F1AC(u8 taskId)
+{
+    gTasks[taskId].data[6] = (u32)(sub_819CC24) >> 0x10;
+    gTasks[taskId].data[7] = (u32)(sub_819CC24);
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].data[5] = 0;
+    gTasks[taskId].func = sub_819D588;
+}
+
+void sub_819F1DC(u8 taskId)
+{
+    gTasks[taskId].data[6] = (u32)(sub_819D9EC) >> 0x10;
+    gTasks[taskId].data[7] = (u32)(sub_819D9EC);
+    gTasks[taskId].data[5] = 0;
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].func = sub_819D588;
+}
+
+void sub_819F20C(u8 taskId)
+{
+    if (!sFactorySwapScreen->inEnemyScreen)
+    {
+        gTasks[taskId].data[6] = (u32)(Task_HandleSwapScreenMenu) >> 0x10;
+        gTasks[taskId].data[7] = (u32)(Task_HandleSwapScreenMenu);
+        gTasks[taskId].data[5] = 2;
+    }
+    else if (Swap_AlreadyHasSameSpecies(sFactorySwapScreen->cursorPos) == TRUE)
+    {
+        sub_819F2B4(&sFactorySwapScreen->unk2C.field1, &sFactorySwapScreen->unk30, TRUE);
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].data[5] = 1;
+        gTasks[taskId].func = Task_SwapCantHaveSameMons;
+        return;
+    }
+    else
+    {
+        gTasks[taskId].data[6] = (u32)(sub_819CCD4) >> 0x10;
+        gTasks[taskId].data[7] = (u32)(sub_819CCD4);
+        gTasks[taskId].data[5] = 0;
+    }
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].func = sub_819D588;
+}
+
+void sub_819F2B4(u8 *arg0, bool8 *arg1, bool8 swapScreen)
+{
+    *arg0 = CreateSprite(&gUnknown_08610894, 120, 64, 1);
+    gSprites[*arg0].callback = sub_819F600;
+    gSprites[*arg0].data[7] = swapScreen;
+    *arg1 = TRUE;
+}
+
+void Swap_ShowSummaryMonSprite(void)
+{
+    struct Pokemon *mon;
+    u16 species;
+    u32 personality, otId;
+
+    sFactorySwapScreen->unk2C.field1 = CreateSprite(&gUnknown_08610894, 120, 64, 1);
+    StartSpriteAffineAnim(&gSprites[sFactorySwapScreen->unk2C.field1], 2);
+
+    mon = &gPlayerParty[sFactorySwapScreen->cursorPos];
+    species = GetMonData(mon, MON_DATA_SPECIES, NULL);
+    personality = GetMonData(mon, MON_DATA_PERSONALITY, NULL);
+    otId = GetMonData(mon, MON_DATA_OT_ID, NULL);
+
+    sFactorySwapScreen->unk2C.field0 = CreateMonPicSprite_HandleDeoxys(species, personality, otId, TRUE, 88, 32, 15, 0xFFFF); // BUG: otId and personality should be switched.
+    gSprites[sFactorySwapScreen->unk2C.field0].centerToCornerVecX = 0;
+    gSprites[sFactorySwapScreen->unk2C.field0].centerToCornerVecY = 0;
+
+    gSprites[sFactorySwapScreen->unk2C.field1].invisible = 1;
+}
+
+void sub_819F3F8(struct UnkFactoryStruct arg0, bool8 *arg1, bool8 swapScreen)
+{
+    u8 taskId;
+
+    FreeAndDestroyMonPicSprite(arg0.field0);
+    taskId = CreateTask(sub_819F7B4, 1);
+    gTasks[taskId].data[7] = swapScreen;
+    gTasks[taskId].data[6] = arg0.field1;
+    gTasks[taskId].func(taskId);
+    *arg1 = TRUE;
+}
+
+void sub_819F444(struct UnkFactoryStruct arg0, bool8 *arg1)
+{
+    FreeAndDestroyMonPicSprite(arg0.field0);
+    FreeOamMatrix(gSprites[arg0.field1].oam.matrixNum);
+    DestroySprite(&gSprites[arg0.field1]);
+    *arg1 = FALSE;
+}
+
+void Task_SwapCantHaveSameMons(u8 taskId)
+{
+    if (sFactorySwapScreen->unk30 == TRUE)
+        return;
+
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        Swap_PrintOnInfoWindow(gText_SamePkmnInPartyAlready);
+        sFactorySwapScreen->monSwapped = FALSE;
+        gTasks[taskId].data[0]++;
+        break;
+    case 1:
+        if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON)
+        {
+            PlaySE(SE_SELECT);
+            sub_819F3F8(sFactorySwapScreen->unk2C, &sFactorySwapScreen->unk30, TRUE);
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 2:
+        if (sFactorySwapScreen->unk30 != TRUE)
+        {
+            FillWindowPixelBuffer(5, 0);
+            CopyWindowToVram(5, 2);
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 3:
+        Swap_PrintOnInfoWindow(gText_SelectPkmnToAccept);
+        gTasks[taskId].data[0]++;
+        break;
+    case 4:
+        Swap_PrintMonSpecies3();
+        sub_819EADC();
+        sFactorySwapScreen->unk22 = 1;
+        gTasks[taskId].data[0] = gTasks[taskId].data[5];
+        gTasks[taskId].func = Task_HandleSwapScreenChooseMons;
+        break;
+    }
+}
+
+bool8 Swap_AlreadyHasSameSpecies(u8 monId)
+{
+    u8 i;
+    u16 species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, NULL);
+
+    for (i = 0; i < 3; i++)
+    {
+        if (i != sFactorySwapScreen->playerMonId && (u16)(GetMonData(&gPlayerParty[i], MON_DATA_SPECIES, NULL)) == species)
+            return TRUE;
+    }
+    return FALSE;
+}
diff --git a/src/battle_interface.c b/src/battle_interface.c
index 278edb6f4..e45af2bf0 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -2589,7 +2589,7 @@ static u8* AddTextPrinterAndCreateWindowOnHealthbox(const u8 *str, u32 x, u32 y,
     color[1] = 1;
     color[2] = 3;
 
-    AddTextPrinterParameterized2(winId, 0, x, y, 0, 0, color, -1, str);
+    AddTextPrinterParameterized4(winId, 0, x, y, 0, 0, color, -1, str);
 
     *windowId = winId;
     return (u8*)(GetWindowAttribute(winId, WINDOW_TILE_DATA));
diff --git a/src/battle_pyramid_bag.c b/src/battle_pyramid_bag.c
index bc2821d16..74a4d3f83 100644
--- a/src/battle_pyramid_bag.c
+++ b/src/battle_pyramid_bag.c
@@ -1129,7 +1129,7 @@ static void sub_81C6404(void)
     StringExpandPlaceholders(gStringVar4, gText_xVar1);
     sub_81C6CEC(3);
     x = GetStringCenterAlignXOffset(1, gStringVar4, 0x28);
-    PrintTextOnWindow(3, 1, gStringVar4, x, 2, 0, NULL);
+    AddTextPrinterParameterized(3, 1, gStringVar4, x, 2, 0, NULL);
 }
 
 static void sub_81C645C(s16 value)
@@ -1139,7 +1139,7 @@ static void sub_81C645C(s16 value)
     ConvertIntToDecimalStringN(gStringVar1, value, STR_CONV_MODE_LEADING_ZEROS, 2);
     StringExpandPlaceholders(gStringVar4, gText_xVar1);
     x = GetStringCenterAlignXOffset(1, gStringVar4, 0x28);
-    PrintTextOnWindow(3, 1, gStringVar4, x, 2, 0, NULL);
+    AddTextPrinterParameterized(3, 1, gStringVar4, x, 2, 0, NULL);
 }
 
 static void sub_81C64B4(u8 taskId)
@@ -1412,12 +1412,12 @@ static void sub_81C6BD8(void)
 
 static void PrintOnWindow_Font1(u8 windowId, const u8 *src, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 speed, u8 colorTableId)
 {
-    AddTextPrinterParameterized2(windowId, 1, x, y, letterSpacing, lineSpacing, sColorTable[colorTableId], speed, src);
+    AddTextPrinterParameterized4(windowId, 1, x, y, letterSpacing, lineSpacing, sColorTable[colorTableId], speed, src);
 }
 
 static void PrintOnWindow_Font7(u8 windowId, const u8 *src, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 speed, u8 colorTableId)
 {
-    AddTextPrinterParameterized2(windowId, 7, x, y, letterSpacing, lineSpacing, sColorTable[colorTableId], speed, src);
+    AddTextPrinterParameterized4(windowId, 7, x, y, letterSpacing, lineSpacing, sColorTable[colorTableId], speed, src);
 }
 
 static void sub_81C6CEC(u8 windowId)
diff --git a/src/battle_records.c b/src/battle_records.c
index fc9826e5b..feaec74db 100644
--- a/src/battle_records.c
+++ b/src/battle_records.c
@@ -283,7 +283,7 @@ static void PrintLinkBattleWinsLossesDraws(struct LinkBattleRecord *records)
     StringExpandPlaceholders(gStringVar4, gText_TotalRecordWLD);
 
     x = GetStringCenterAlignXOffset(1, gStringVar4, 0xD0);
-    PrintTextOnWindow(gRecordsWindowId, 1, gStringVar4, x, 0x11, 0, NULL);
+    AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar4, x, 0x11, 0, NULL);
 }
 
 static void PrintLinkBattleRecord(struct LinkBattleRecord *record, u8 y, s32 language)
@@ -291,10 +291,10 @@ static void PrintLinkBattleRecord(struct LinkBattleRecord *record, u8 y, s32 lan
     if (record->wins == 0 && record->losses == 0 && record->draws == 0)
     {
         // empty slot
-        PrintTextOnWindow(gRecordsWindowId, 1, sText_DashesNoPlayer,   8, (y * 8) + 1, 0, NULL);
-        PrintTextOnWindow(gRecordsWindowId, 1, sText_DashesNoScore,  80, (y * 8) + 1, 0, NULL);
-        PrintTextOnWindow(gRecordsWindowId, 1, sText_DashesNoScore, 128, (y * 8) + 1, 0, NULL);
-        PrintTextOnWindow(gRecordsWindowId, 1, sText_DashesNoScore, 176, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, sText_DashesNoPlayer,   8, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, sText_DashesNoScore,  80, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, sText_DashesNoScore, 128, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, sText_DashesNoScore, 176, (y * 8) + 1, 0, NULL);
     }
     else
     {
@@ -302,16 +302,16 @@ static void PrintLinkBattleRecord(struct LinkBattleRecord *record, u8 y, s32 lan
         StringCopyN(gStringVar1, record->name, 7);
         ConvertInternationalString(gStringVar1, language);
 
-        PrintTextOnWindow(gRecordsWindowId, 1, gStringVar1, 8, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar1, 8, (y * 8) + 1, 0, NULL);
 
         ConvertIntToDecimalStringN(gStringVar1, record->wins, STR_CONV_MODE_RIGHT_ALIGN, 4);
-        PrintTextOnWindow(gRecordsWindowId, 1, gStringVar1,  80, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar1,  80, (y * 8) + 1, 0, NULL);
 
         ConvertIntToDecimalStringN(gStringVar1, record->losses, STR_CONV_MODE_RIGHT_ALIGN, 4);
-        PrintTextOnWindow(gRecordsWindowId, 1, gStringVar1, 128, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar1, 128, (y * 8) + 1, 0, NULL);
 
         ConvertIntToDecimalStringN(gStringVar1, record->draws, STR_CONV_MODE_RIGHT_ALIGN, 4);
-        PrintTextOnWindow(gRecordsWindowId, 1, gStringVar1, 176, (y * 8) + 1, 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar1, 176, (y * 8) + 1, 0, NULL);
     }
 }
 
@@ -325,11 +325,11 @@ void ShowLinkBattleRecords(void)
     StringExpandPlaceholders(gStringVar4, gText_PlayersBattleResults);
 
     x = GetStringCenterAlignXOffset(1, gStringVar4, 208);
-    PrintTextOnWindow(gRecordsWindowId, 1, gStringVar4, x, 1, 0, NULL);
+    AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar4, x, 1, 0, NULL);
     PrintLinkBattleWinsLossesDraws(gSaveBlock1Ptr->linkBattleRecords.entries);
 
     StringExpandPlaceholders(gStringVar4, gText_WinLoseDraw);
-    PrintTextOnWindow(gRecordsWindowId, 1, gStringVar4, 0, 41, 0, NULL);
+    AddTextPrinterParameterized(gRecordsWindowId, 1, gStringVar4, 0, 41, 0, NULL);
 
     for (i = 0; i < LINK_B_RECORDS_COUNT; i++)
     {
diff --git a/src/berry_blender.c b/src/berry_blender.c
index 96c3a933d..a5b940189 100644
--- a/src/berry_blender.c
+++ b/src/berry_blender.c
@@ -3550,8 +3550,8 @@ void ShowBerryBlenderRecordWindow(void)
     FillWindowPixelBuffer(gRecordsWindowId, 0x11);
 
     xPos = GetStringCenterAlignXOffset(1, gText_BlenderMaxSpeedRecord, 0x90);
-    PrintTextOnWindow(gRecordsWindowId, 1, gText_BlenderMaxSpeedRecord, xPos, 1, 0, NULL);
-    PrintTextOnWindow(gRecordsWindowId, 1, gText_234Players, 4, 0x29, 0, NULL);
+    AddTextPrinterParameterized(gRecordsWindowId, 1, gText_BlenderMaxSpeedRecord, xPos, 1, 0, NULL);
+    AddTextPrinterParameterized(gRecordsWindowId, 1, gText_234Players, 4, 0x29, 0, NULL);
 
     for (i = 0, yPos = 0x29; i < BLENDER_SCORES_NO; i++)
     {
@@ -3566,7 +3566,7 @@ void ShowBerryBlenderRecordWindow(void)
         txtPtr = StringAppend(txtPtr, sText_RPM);
 
         xPos = GetStringRightAlignXOffset(1, text, 0x8C);
-        PrintTextOnWindow(gRecordsWindowId, 1, text, xPos, yPos + (i * 16), 0, NULL);
+        AddTextPrinterParameterized(gRecordsWindowId, 1, text, xPos, yPos + (i * 16), 0, NULL);
     }
 
     PutWindowTilemap(gRecordsWindowId);
@@ -3659,7 +3659,7 @@ static void Blender_AddTextPrinter(u8 windowId, const u8 *string, u8 x, u8 y, s3
         FillWindowPixelBuffer(windowId, txtColor[0] | (txtColor[0] << 4));
     }
 
-    AddTextPrinterParameterized2(windowId, 1, x, y, letterSpacing, 1, txtColor, speed, string);
+    AddTextPrinterParameterized4(windowId, 1, x, y, letterSpacing, 1, txtColor, speed, string);
 }
 
 static bool32 Blender_PrintText(s16 *textState, const u8 *string, s32 textSpeed)
diff --git a/src/berry_fix_program.c b/src/berry_fix_program.c
index f6a5895a9..2ae15a806 100644
--- a/src/berry_fix_program.c
+++ b/src/berry_fix_program.c
@@ -250,19 +250,19 @@ static void berry_fix_gpu_set(void)
 
     width = GetStringWidth(0, sUnknown_08617E9B, 0);
     left = (0x78 - width) / 2;
-    box_print(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E9B);
+    AddTextPrinterParameterized3(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E9B);
 
     width = GetStringWidth(0, sUnknown_08617E8D, 0);
     left = (0x78 - width) / 2 + 0x78;
-    box_print(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
+    AddTextPrinterParameterized3(2, 0, left, 3, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
 
     width = GetStringWidth(0, sUnknown_08617E8D, 0);
     left = (0x70 - width) / 2;
-    box_print(3, 0, left, 0, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
+    AddTextPrinterParameterized3(3, 0, left, 0, sUnknown_0861815B, TEXT_SPEED_FF, sUnknown_08617E8D);
 
     width = GetStringWidth(1, sUnknown_08617E78, 0);
     left = (0xD0 - width) / 2;
-    box_print(0, 1, left, 2, sUnknown_08618158, TEXT_SPEED_FF, sUnknown_08617E78);
+    AddTextPrinterParameterized3(0, 1, left, 2, sUnknown_08618158, TEXT_SPEED_FF, sUnknown_08617E78);
 
     CopyWindowToVram(2, 2);
     CopyWindowToVram(3, 2);
@@ -292,7 +292,7 @@ static void berry_fix_text_print(int scene)
 {
     FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
     FillWindowPixelBuffer(1, 0xAA);
-    box_print(1, 1, 0, 0, sUnknown_08618158, -1, gUnknown_08618160[scene]);
+    AddTextPrinterParameterized3(1, 1, 0, 0, sUnknown_08618158, -1, gUnknown_08618160[scene]);
     PutWindowTilemap(1);
     CopyWindowToVram(1, 2);
     switch (scene)
diff --git a/src/berry_tag_screen.c b/src/berry_tag_screen.c
index 0c13e7085..d30af944e 100644
--- a/src/berry_tag_screen.c
+++ b/src/berry_tag_screen.c
@@ -375,7 +375,7 @@ static void HandleInitWindows(void)
 
 static void PrintTextInBerryTagScreen(u8 windowId, const u8 *text, u8 x, u8 y, s32 speed, u8 colorStructId)
 {
-    AddTextPrinterParameterized2(windowId, 1, x, y, 0, 0, sTextColors[colorStructId], speed, text);
+    AddTextPrinterParameterized4(windowId, 1, x, y, 0, 0, sTextColors[colorStructId], speed, text);
 }
 
 static void AddBerryTagTextToBg0(void)
@@ -408,7 +408,7 @@ static void PrintBerryNumberAndName(void)
 static void PrintBerrySize(void)
 {
     const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
-    PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_SizeSlash, 0, 1, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, gText_SizeSlash, 0, 1, TEXT_SPEED_FF, NULL);
     if (berry->size != 0)
     {
         u32 inches, fraction;
@@ -422,34 +422,34 @@ static void PrintBerrySize(void)
         ConvertIntToDecimalStringN(gStringVar1, inches, 0, 2);
         ConvertIntToDecimalStringN(gStringVar2, fraction, 0, 2);
         StringExpandPlaceholders(gStringVar4, gText_Var1DotVar2);
-        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gStringVar4, 0x28, 1, 0, NULL);
+        AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, gStringVar4, 0x28, 1, 0, NULL);
     }
     else
     {
-        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 1, 0, NULL);
+        AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 1, 0, NULL);
     }
 }
 
 static void PrintBerryFirmness(void)
 {
     const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
-    PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_FirmSlash, 0, 0x11, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, gText_FirmSlash, 0, 0x11, TEXT_SPEED_FF, NULL);
     if (berry->firmness != 0)
-        PrintTextOnWindow(WIN_SIZE_FIRM, 1, sBerryFirmnessStrings[berry->firmness - 1], 0x28, 0x11, 0, NULL);
+        AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, sBerryFirmnessStrings[berry->firmness - 1], 0x28, 0x11, 0, NULL);
     else
-        PrintTextOnWindow(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 0x11, 0, NULL);
+        AddTextPrinterParameterized(WIN_SIZE_FIRM, 1, gText_ThreeMarks, 0x28, 0x11, 0, NULL);
 }
 
 static void PrintBerryDescription1(void)
 {
     const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
-    PrintTextOnWindow(WIN_DESC, 1, berry->description1, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(WIN_DESC, 1, berry->description1, 0, 1, 0, NULL);
 }
 
 static void PrintBerryDescription2(void)
 {
     const struct Berry *berry = GetBerryInfo(sBerryTag->berryId);
-    PrintTextOnWindow(WIN_DESC, 1, berry->description2, 0, 0x11, 0, NULL);
+    AddTextPrinterParameterized(WIN_DESC, 1, berry->description2, 0, 0x11, 0, NULL);
 }
 
 static void CreateBerrySprite(void)
diff --git a/src/clear_save_data_screen.c b/src/clear_save_data_screen.c
index 5c1f7db20..839a77e4a 100644
--- a/src/clear_save_data_screen.c
+++ b/src/clear_save_data_screen.c
@@ -79,7 +79,7 @@ void CB2_InitClearSaveDataScreen(void)
 static void Task_DoClearSaveDataScreenYesNo(u8 taskId)
 {
     SetWindowBorderStyle(0, 0, 2, 14);
-    PrintTextOnWindow(0, 1, gText_ClearAllSaveData, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, gText_ClearAllSaveData, 0, 1, 0, 0);
     CreateYesNoMenu(sClearSaveYesNo, 2, 14, 1);
     gTasks[taskId].func = Task_ClearSaveDataScreenYesNoChoice;
 }
@@ -90,7 +90,7 @@ static void Task_ClearSaveDataScreenYesNoChoice(u8 taskId)
     {
         case 0:
             FillWindowPixelBuffer(0, 17);
-            PrintTextOnWindow(0, 1, gText_ClearingData, 0, 1, 0, 0);
+            AddTextPrinterParameterized(0, 1, gText_ClearingData, 0, 1, 0, 0);
             gTasks[taskId].func = Task_ClearSaveData;
             break;
         case 1:
diff --git a/src/coins.c b/src/coins.c
index 12e0bd4ef..967eb92ac 100644
--- a/src/coins.c
+++ b/src/coins.c
@@ -19,7 +19,7 @@ void PrintCoinsString(u32 coinAmount)
     StringExpandPlaceholders(gStringVar4, gText_Coins);
 
     xAlign = GetStringRightAlignXOffset(1, gStringVar4, 0x40);
-    PrintTextOnWindow(sCoinsWindowId, 1, gStringVar4, xAlign, 1, 0, NULL);
+    AddTextPrinterParameterized(sCoinsWindowId, 1, gStringVar4, xAlign, 1, 0, NULL);
 }
 
 void ShowCoinsWindow(u32 coinAmount, u8 x, u8 y)
diff --git a/src/credits.c b/src/credits.c
index cbf77f1b3..94089a6d1 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -1197,7 +1197,7 @@ static void sub_81755BC(const u8 *string, u8 y, u8 a2)
     }
     
     x = GetStringCenterAlignXOffsetWithLetterSpacing(1, string, 0xF0, 1);
-    AddTextPrinterParameterized2(0, 1, x, y, 1, 0, color, -1, string);
+    AddTextPrinterParameterized4(0, 1, x, y, 1, 0, color, -1, string);
 }
 
 void sub_8175620(void)
diff --git a/src/decoration.c b/src/decoration.c
index e1def6d38..94edbe956 100644
--- a/src/decoration.c
+++ b/src/decoration.c
@@ -544,7 +544,7 @@ void sub_8126B80(u8 taskId)
 void sub_8126C08(void)
 {
     FillWindowPixelBuffer(0, 0x11);
-    AddTextPrinterParameterized(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3);
 }
 
 void SecretBasePC_Decorate(u8 taskId)
@@ -667,7 +667,7 @@ void sub_8126E8C(u8 taskId)
             sub_8126F68(r5, i, 8, i << 4, FALSE, 0xFF);
         }
     }
-    PrintTextOnWindow(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0);
+    AddTextPrinterParameterized(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0);
     schedule_bg_copy_tilemap_to_vram(0);
 }
 
@@ -681,12 +681,12 @@ void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed)
     sub_8127058(gStringVar4, flag);
     strbuf = StringLength(gStringVar4) + gStringVar4;
     StringCopy(strbuf, sDecorCatNames[decorCat]);
-    PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+    AddTextPrinterParameterized(winid, 1, gStringVar4, x, y, speed, NULL);
     strbuf = ConvertIntToDecimalStringN(strbuf, CountDecorationCategoryN(decorCat), STR_CONV_MODE_RIGHT_ALIGN, 2);
     *strbuf++ = CHAR_SLASH;
     ConvertIntToDecimalStringN(strbuf, gDecorationInventories[decorCat].size, STR_CONV_MODE_RIGHT_ALIGN, 2);
     x = GetStringRightAlignXOffset(1, gStringVar4, width);
-    PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+    AddTextPrinterParameterized(winid, 1, gStringVar4, x, y, speed, NULL);
 }
 
 void sub_8127058(u8 *str, bool8 flag)
@@ -977,7 +977,7 @@ void sub_8127744(u32 a0)
     {
         txt = gDecorations[gCurDecorInventoryItems[a0]].description;
     }
-    PrintTextOnWindow(winidx, 1, txt, 0, 1, 0, 0);
+    AddTextPrinterParameterized(winidx, 1, txt, 0, 1, 0, 0);
 }
 
 void sub_81277A8(void)
diff --git a/src/diploma.c b/src/diploma.c
index 599ceec72..8e0b48ed3 100644
--- a/src/diploma.c
+++ b/src/diploma.c
@@ -17,7 +17,7 @@ extern int decompress_and_copy_tile_data_to_vram(u8 bg_id, void *src, int size,
 extern bool8 free_temp_tile_data_buffers_if_possible(void);
 extern void sub_80861E8(void); // rom4
 extern bool16 sub_80C0944(void);
-extern void AddTextPrinterParameterized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 *color, s8 speed, u8 *str);
+extern void AddTextPrinterParameterized4(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 *color, s8 speed, u8 *str);
 
 extern u16 gUnknown_0860F074[];
 
@@ -210,5 +210,5 @@ static void PrintDiplomaText(u8 *text, u8 var1, u8 var2)
 {
     u8 color[3] = {0, 2, 3};
 
-    AddTextPrinterParameterized2(0, 1, var1, var2, 0, 0, color, -1, text);
+    AddTextPrinterParameterized4(0, 1, var1, var2, 0, 0, color, -1, text);
 }
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index 25af28da4..d56f03028 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -870,7 +870,7 @@ static void EggHatchPrintMessage(u8 windowId, u8* string, u8 x, u8 y, u8 speed)
     sEggHatchData->textColor[0] = 0;
     sEggHatchData->textColor[1] = 5;
     sEggHatchData->textColor[2] = 6;
-    AddTextPrinterParameterized2(windowId, 1, x, y, 0, 0, sEggHatchData->textColor, speed, string);
+    AddTextPrinterParameterized4(windowId, 1, x, y, 0, 0, sEggHatchData->textColor, speed, string);
 }
 
 u8 GetEggStepsToSubtract(void)
diff --git a/src/field_region_map.c b/src/field_region_map.c
index d77bde01b..7e8794cab 100644
--- a/src/field_region_map.c
+++ b/src/field_region_map.c
@@ -143,7 +143,7 @@ static void FieldUpdateRegionMap(void)
         case 1:
             SetWindowBorderStyle(1, 0, 0x27, 0xd);
             offset = GetStringCenterAlignXOffset(1, gText_Hoenn, 0x38);
-            PrintTextOnWindow(1, 1, gText_Hoenn, offset, 1, 0, NULL);
+            AddTextPrinterParameterized(1, 1, gText_Hoenn, offset, 1, 0, NULL);
             schedule_bg_copy_tilemap_to_vram(0);
             SetWindowBorderStyle(0, 0, 0x27, 0xd);
             PrintRegionMapSecName();
@@ -199,7 +199,7 @@ static void PrintRegionMapSecName(void)
     if (sFieldRegionMapHandler->regionMap.iconDrawType != MAPSECTYPE_NONE)
     {
         FillWindowPixelBuffer(0, 0x11);
-        PrintTextOnWindow(0, 1, sFieldRegionMapHandler->regionMap.mapSecName, 0, 1, 0, NULL);
+        AddTextPrinterParameterized(0, 1, sFieldRegionMapHandler->regionMap.mapSecName, 0, 1, 0, NULL);
         schedule_bg_copy_tilemap_to_vram(0);
     }
     else
diff --git a/src/field_specials.c b/src/field_specials.c
index 14f99b426..113979375 100644
--- a/src/field_specials.c
+++ b/src/field_specials.c
@@ -1836,10 +1836,10 @@ void sub_8139B60(void)
     SetStandardWindowBorderStyle(gUnknown_0203AB5E, 0);
 
     xPos = GetStringCenterAlignXOffset(1, gText_ElevatorNowOn, 64);
-    PrintTextOnWindow(gUnknown_0203AB5E, 1, gText_ElevatorNowOn, xPos, 1, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(gUnknown_0203AB5E, 1, gText_ElevatorNowOn, xPos, 1, TEXT_SPEED_FF, NULL);
 
     xPos = GetStringCenterAlignXOffset(1, gElevatorFloorsTable[gSpecialVar_0x8005], 64);
-    PrintTextOnWindow(gUnknown_0203AB5E, 1, gElevatorFloorsTable[gSpecialVar_0x8005], xPos, 17, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(gUnknown_0203AB5E, 1, gElevatorFloorsTable[gSpecialVar_0x8005], xPos, 17, TEXT_SPEED_FF, NULL);
 
     PutWindowTilemap(gUnknown_0203AB5E);
     CopyWindowToVram(gUnknown_0203AB5E, 3);
@@ -2178,13 +2178,13 @@ void sub_8139F20(void)
             }
             break;
         case 5:
-            if (gSaveBlock2Ptr->frontier.field_DE2[0] >= gSaveBlock2Ptr->frontier.field_DE2[1])
+            if (gSaveBlock2Ptr->frontier.field_DE2[0][0] >= gSaveBlock2Ptr->frontier.field_DE2[0][1])
             {
-                unk = gSaveBlock2Ptr->frontier.field_DE2[0];
+                unk = gSaveBlock2Ptr->frontier.field_DE2[0][0];
             }
             else
             {
-                unk = gSaveBlock2Ptr->frontier.field_DE2[1];
+                unk = gSaveBlock2Ptr->frontier.field_DE2[0][1];
             }
             break;
         case 6:
@@ -3063,7 +3063,7 @@ void sub_813A8FC(void)
     u32 x;
     StringCopy(ConvertIntToDecimalStringN(string, gSaveBlock2Ptr->frontier.frontierBattlePoints, STR_CONV_MODE_RIGHT_ALIGN, 4), gText_BP);
     x = GetStringRightAlignXOffset(1, string, 48);
-    PrintTextOnWindow(gUnknown_0203AB6D, 1, string, x, 1, 0, NULL);
+    AddTextPrinterParameterized(gUnknown_0203AB6D, 1, string, x, 1, 0, NULL);
 }
 
 void sub_813A958(void)
@@ -3201,7 +3201,7 @@ static void sub_813AA60(u16 a0, u16 a1)
         switch (a0)
         {
             case 3:
-                AddTextPrinterParameterized(0, 1, gUnknown_085B3170[a1], 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gUnknown_085B3170[a1], 0, NULL, 2, 1, 3);
                 if (gUnknown_085B312C[a1] == 0xFFFF)
                 {
                     sub_813ABD4(gUnknown_085B312C[a1]);
@@ -3214,7 +3214,7 @@ static void sub_813AA60(u16 a0, u16 a1)
                 }
                 break;
             case 4:
-                AddTextPrinterParameterized(0, 1, gUnknown_085B319C[a1], 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gUnknown_085B319C[a1], 0, NULL, 2, 1, 3);
                 if (gUnknown_085B3142[a1] == 0xFFFF)
                 {
                     sub_813ABD4(gUnknown_085B3142[a1]);
@@ -3227,11 +3227,11 @@ static void sub_813AA60(u16 a0, u16 a1)
                 }
                 break;
             case 5:
-                AddTextPrinterParameterized(0, 1, gUnknown_085B31B4[a1], 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gUnknown_085B31B4[a1], 0, NULL, 2, 1, 3);
                 sub_813ABD4(gUnknown_085B314E[a1]);
                 break;
             case 6:
-                AddTextPrinterParameterized(0, 1, gUnknown_085B31D0[a1], 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gUnknown_085B31D0[a1], 0, NULL, 2, 1, 3);
                 sub_813ABD4(gUnknown_085B315C[a1]);
                 break;
         }
@@ -3339,11 +3339,11 @@ static void sub_813AD34(u8 a0, u16 a1)
         FillWindowPixelRect(gUnknown_0203AB5E, 0x11, 0, 0, 96, 48);
         if (a0 == 10)
         {
-            PrintTextOnWindow(gUnknown_0203AB5E, 1, gUnknown_085B3254[a1], 0, 1, 0, NULL);
+            AddTextPrinterParameterized(gUnknown_0203AB5E, 1, gUnknown_085B3254[a1], 0, 1, 0, NULL);
         }
         else
         {
-            PrintTextOnWindow(gUnknown_0203AB5E, 1, gUnknown_085B3228[a1], 0, 1, 0, NULL);
+            AddTextPrinterParameterized(gUnknown_0203AB5E, 1, gUnknown_085B3228[a1], 0, 1, 0, NULL);
         }
     }
 }
@@ -3367,10 +3367,10 @@ void sub_813ADD4(void)
 
         for (i = 0; i < 6; i++)
         {
-            sub_8199F74(task->data[13], 1, gUnknown_085B2CF0[gSpecialVar_0x8004][scrollOffset + i], 10, i * 16, TEXT_SPEED_FF, NULL, 0, 0);
+            AddTextPrinterParameterized5(task->data[13], 1, gUnknown_085B2CF0[gSpecialVar_0x8004][scrollOffset + i], 10, i * 16, TEXT_SPEED_FF, NULL, 0, 0);
         }
 
-        PrintTextOnWindow(task->data[13], 1, gText_SelectorArrow, 0, selectedRow * 16, TEXT_SPEED_FF, NULL);
+        AddTextPrinterParameterized(task->data[13], 1, gText_SelectorArrow, 0, selectedRow * 16, TEXT_SPEED_FF, NULL);
         PutWindowTilemap(task->data[13]);
         CopyWindowToVram(task->data[13], 3);
     }
diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c
index 33c85d448..b739ba66d 100644
--- a/src/hall_of_fame.c
+++ b/src/hall_of_fame.c
@@ -531,7 +531,7 @@ static void Task_Hof_InitTeamSaveData(u8 taskId)
     *lastSavedTeam = *sHofMonPtr;
 
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    AddTextPrinterParameterized(0, 1, gText_SavingDontTurnOffPower, 0, NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gText_SavingDontTurnOffPower, 0, NULL, 2, 1, 3);
     CopyWindowToVram(0, 3);
     gTasks[taskId].func = Task_Hof_TrySaveData;
 }
@@ -738,7 +738,7 @@ static void Task_Hof_WaitAndPrintPlayerInfo(u8 taskId)
         FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
         HallOfFame_PrintPlayerInfo(1, 2);
         NewMenuHelpers_DrawDialogueFrame(0, 0);
-        AddTextPrinterParameterized(0, 1, gText_LeagueChamp, 0, NULL, 2, 1, 3);
+        AddTextPrinterParameterized2(0, 1, gText_LeagueChamp, 0, NULL, 2, 1, 3);
         CopyWindowToVram(0, 3);
         gTasks[taskId].func = Task_Hof_ExitOnKeyPressed;
     }
@@ -1107,7 +1107,7 @@ static void Task_HofPC_PrintDataIsCorrupted(u8 taskId)
 {
     sub_8198180(gText_UnkCtrlF800Exit, 8, 1);
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    AddTextPrinterParameterized(0, 1, gText_HOFCorrupted, 0, NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gText_HOFCorrupted, 0, NULL, 2, 1, 3);
     CopyWindowToVram(0, 3);
     gTasks[taskId].func = Task_HofPC_ExitOnButtonPress;
 }
@@ -1128,7 +1128,7 @@ static void HallOfFame_PrintWelcomeText(u8 unusedPossiblyWindowId, u8 unused2)
 {
     FillWindowPixelBuffer(0, 0);
     PutWindowTilemap(0);
-    box_print(0, 1, GetStringCenterAlignXOffset(1, gText_WelcomeToHOF, 0xD0), 1, sUnknown_085E5388, 0, gText_WelcomeToHOF);
+    AddTextPrinterParameterized3(0, 1, GetStringCenterAlignXOffset(1, gText_WelcomeToHOF, 0xD0), 1, sUnknown_085E5388, 0, gText_WelcomeToHOF);
     CopyWindowToVram(0, 3);
 }
 
@@ -1164,7 +1164,7 @@ static void HallOfFame_PrintMonInfo(struct HallofFameMon* currMon, u8 unused1, u
             *(stringPtr)++ = CHAR_QUESTION_MARK;
         }
         stringPtr[0] = EOS;
-        box_print(0, 1, 0x10, 1, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, 0x10, 1, sUnknown_085E5388, -1, text);
     }
 
     // nick, species names, gender and level
@@ -1173,13 +1173,13 @@ static void HallOfFame_PrintMonInfo(struct HallofFameMon* currMon, u8 unused1, u
     if (currMon->species == SPECIES_EGG)
     {
         width = GetStringCenterAlignXOffset(1, text, 0xD0);
-        box_print(0, 1, width, 1, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, width, 1, sUnknown_085E5388, -1, text);
         CopyWindowToVram(0, 3);
     }
     else
     {
         width = GetStringRightAlignXOffset(1, text, 0x80);
-        box_print(0, 1, width, 1, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, width, 1, sUnknown_085E5388, -1, text);
 
         text[0] = CHAR_SLASH;
         stringPtr = StringCopy(text + 1, gSpeciesNames[currMon->species]);
@@ -1200,15 +1200,15 @@ static void HallOfFame_PrintMonInfo(struct HallofFameMon* currMon, u8 unused1, u
         }
 
         stringPtr[0] = EOS;
-        box_print(0, 1, 0x80, 1, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, 0x80, 1, sUnknown_085E5388, -1, text);
 
         stringPtr = StringCopy(text, gText_Level);
         ConvertIntToDecimalStringN(stringPtr, currMon->lvl, STR_CONV_MODE_LEFT_ALIGN, 3);
-        box_print(0, 1, 0x24, 0x11, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, 0x24, 0x11, sUnknown_085E5388, -1, text);
 
         stringPtr = StringCopy(text, gText_IDNumber);
         ConvertIntToDecimalStringN(stringPtr, (u16)(currMon->tid), STR_CONV_MODE_LEADING_ZEROS, 5);
-        box_print(0, 1, 0x68, 0x11, sUnknown_085E5388, -1, text);
+        AddTextPrinterParameterized3(0, 1, 0x68, 0x11, sUnknown_085E5388, -1, text);
 
         CopyWindowToVram(0, 3);
     }
@@ -1223,13 +1223,13 @@ static void HallOfFame_PrintPlayerInfo(u8 unused1, u8 unused2)
     FillWindowPixelBuffer(1, 0x11);
     PutWindowTilemap(1);
     SetWindowBorderStyle(1, FALSE, 0x21D, 0xD);
-    box_print(1, 1, 0, 1, sUnknown_085E538C, -1, gText_Name);
+    AddTextPrinterParameterized3(1, 1, 0, 1, sUnknown_085E538C, -1, gText_Name);
 
     width = GetStringRightAlignXOffset(1, gSaveBlock2Ptr->playerName, 0x70);
-    box_print(1, 1, width, 1, sUnknown_085E538C, -1, gSaveBlock2Ptr->playerName);
+    AddTextPrinterParameterized3(1, 1, width, 1, sUnknown_085E538C, -1, gSaveBlock2Ptr->playerName);
 
     trainerId = (gSaveBlock2Ptr->playerTrainerId[0]) | (gSaveBlock2Ptr->playerTrainerId[1] << 8);
-    box_print(1, 1, 0, 0x11, sUnknown_085E538C, 0, gText_IDNumber);
+    AddTextPrinterParameterized3(1, 1, 0, 0x11, sUnknown_085E538C, 0, gText_IDNumber);
     text[0] = (trainerId % 100000) / 10000 + CHAR_0;
     text[1] = (trainerId % 10000) / 1000 + CHAR_0;
     text[2] = (trainerId % 1000) / 100 + CHAR_0;
@@ -1237,9 +1237,9 @@ static void HallOfFame_PrintPlayerInfo(u8 unused1, u8 unused2)
     text[4] = (trainerId % 10) / 1 + CHAR_0;
     text[5] = EOS;
     width = GetStringRightAlignXOffset(1, text, 0x70);
-    box_print(1, 1, width, 0x11, sUnknown_085E538C, -1, text);
+    AddTextPrinterParameterized3(1, 1, width, 0x11, sUnknown_085E538C, -1, text);
 
-    box_print(1, 1, 0, 0x21, sUnknown_085E538C, -1, gText_MainMenuTime);
+    AddTextPrinterParameterized3(1, 1, 0, 0x21, sUnknown_085E538C, -1, gText_MainMenuTime);
     text[0] = (gSaveBlock2Ptr->playTimeHours / 100) + CHAR_0;
     text[1] = (gSaveBlock2Ptr->playTimeHours % 100) / 10 + CHAR_0;
     text[2] = (gSaveBlock2Ptr->playTimeHours % 10) + CHAR_0;
@@ -1255,7 +1255,7 @@ static void HallOfFame_PrintPlayerInfo(u8 unused1, u8 unused2)
     text[6] = EOS;
 
     width = GetStringRightAlignXOffset(1, text, 0x70);
-    box_print(1, 1, width, 0x21, sUnknown_085E538C, -1, text);
+    AddTextPrinterParameterized3(1, 1, width, 0x21, sUnknown_085E538C, -1, text);
 
     CopyWindowToVram(1, 3);
 }
diff --git a/src/item_menu.c b/src/item_menu.c
index 082fe5558..938277210 100755
--- a/src/item_menu.c
+++ b/src/item_menu.c
@@ -1057,7 +1057,7 @@ void sub_81ABC54(u8 a, s16 b)
     u8 r3 = (gUnknown_0203CE58.pocket == 3) ? 3 : 2;
     ConvertIntToDecimalStringN(gStringVar1, b, 2, r3);
     StringExpandPlaceholders(gStringVar4, gText_xVar1);
-    PrintTextOnWindow(a, 1, gStringVar4, GetStringCenterAlignXOffset(1, gStringVar4, 0x28), 2, 0, 0);
+    AddTextPrinterParameterized(a, 1, gStringVar4, GetStringCenterAlignXOffset(1, gStringVar4, 0x28), 2, 0, 0);
 }
 
 void sub_81ABCC0(int a, int b, int c)
@@ -1065,7 +1065,7 @@ void sub_81ABCC0(int a, int b, int c)
     u8 r3 = (gUnknown_0203CE58.pocket == 3) ? 3 : 2;
     ConvertIntToDecimalStringN(gStringVar1, b, 2, r3);
     StringExpandPlaceholders(gStringVar4, gText_xVar1);
-    PrintTextOnWindow(a, 1, gStringVar4, 0, 1, -1, 0);
+    AddTextPrinterParameterized(a, 1, gStringVar4, 0, 1, -1, 0);
     PrintMoneyAmount(a, 0x26, 1, c, 0);
 }
 
@@ -2291,7 +2291,7 @@ void setup_bag_menu_textboxes(void)
 
 void bag_menu_print(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 letterSpacing, u8 lineSpacing, u8 speed, u8 h)
 {
-    AddTextPrinterParameterized2(windowId, fontId, left, top, letterSpacing, lineSpacing, gUnknown_08614164[h], speed, str);
+    AddTextPrinterParameterized4(windowId, fontId, left, top, letterSpacing, lineSpacing, gUnknown_08614164[h], speed, str);
 }
 
 u8 sub_81AE124(u8 a)
diff --git a/src/learn_move.c b/src/learn_move.c
index e288a393d..ff23cb3dc 100644
--- a/src/learn_move.c
+++ b/src/learn_move.c
@@ -632,7 +632,7 @@ static void HideSpritesAndPrintTeachText(bool8 a)
     {
         StringExpandPlaceholders(gStringVar4, gText_TeachWhichMoveToPkmn);
         FillWindowPixelBuffer(3, 0x11);
-        PrintTextOnWindow(3, 1, gStringVar4, 0, 1, 0, NULL);
+        AddTextPrinterParameterized(3, 1, gStringVar4, 0, 1, 0, NULL);
     }
 }
 
@@ -696,7 +696,7 @@ static void ShowTeachMoveText(bool8 showContest)
     {
         StringExpandPlaceholders(gStringVar4, gText_TeachWhichMoveToPkmn);
         FillWindowPixelBuffer(3, 0x11);
-        PrintTextOnWindow(3, 1, gStringVar4, 0, 1, 0, NULL);
+        AddTextPrinterParameterized(3, 1, gStringVar4, 0, 1, 0, NULL);
     }
 }
 
diff --git a/src/link.c b/src/link.c
index 457e44a01..627327181 100644
--- a/src/link.c
+++ b/src/link.c
@@ -1685,8 +1685,8 @@ static void sub_800B080(void)
     LoadPalette(gWirelessLinkDisplayPal, 0, 0x20);
     FillWindowPixelBuffer(0, 0x00);
     FillWindowPixelBuffer(2, 0x00);
-    box_print(0, 3, 2, 6, gUnknown_082ED224, 0, gText_CommErrorEllipsis);
-    box_print(2, 3, 2, 1, gUnknown_082ED224, 0, gText_MoveCloserToLinkPartner);
+    AddTextPrinterParameterized3(0, 3, 2, 6, gUnknown_082ED224, 0, gText_CommErrorEllipsis);
+    AddTextPrinterParameterized3(2, 3, 2, 1, gUnknown_082ED224, 0, gText_MoveCloserToLinkPartner);
     PutWindowTilemap(0);
     PutWindowTilemap(2);
     CopyWindowToVram(0, 0);
@@ -1698,7 +1698,7 @@ static void sub_800B138(void)
     LoadBgTiles(0, g2BlankTilesGfx, 0x20, 0);
     FillWindowPixelBuffer(1, 0x00);
     FillWindowPixelBuffer(2, 0x00);
-    box_print(1, 3, 2, 0, gUnknown_082ED224, 0, gText_CommErrorCheckConnections);
+    AddTextPrinterParameterized3(1, 3, 2, 0, gUnknown_082ED224, 0, gText_CommErrorCheckConnections);
     PutWindowTilemap(1);
     PutWindowTilemap(2);
     CopyWindowToVram(1, 0);
@@ -1738,11 +1738,11 @@ static void CB2_PrintErrorMessage(void)
         case 130:
             if (gWirelessCommType == 2)
             {
-                box_print(0, 3, 2, 20, gUnknown_082ED224, 0, gText_ABtnTitleScreen);
+                AddTextPrinterParameterized3(0, 3, 2, 20, gUnknown_082ED224, 0, gText_ABtnTitleScreen);
             }
             else if (gWirelessCommType == 1)
             {
-                box_print(0, 3, 2, 20, gUnknown_082ED224, 0, gText_ABtnRegistrationCounter);
+                AddTextPrinterParameterized3(0, 3, 2, 20, gUnknown_082ED224, 0, gText_ABtnRegistrationCounter);
             }
             break;
     }
diff --git a/src/list_menu.c b/src/list_menu.c
index 6b5c3af94..ec45ba3e4 100644
--- a/src/list_menu.c
+++ b/src/list_menu.c
@@ -600,7 +600,7 @@ static void ListMenuPrint(struct ListMenu *list, const u8 *str, u8 x, u8 y)
         colors[0] = gListMenuOverride.fillValue;
         colors[1] = gListMenuOverride.cursorPal;
         colors[2] = gListMenuOverride.cursorShadowPal;
-        AddTextPrinterParameterized2(list->template.windowId,
+        AddTextPrinterParameterized4(list->template.windowId,
                                      gListMenuOverride.fontId,
                                      x, y,
                                      gListMenuOverride.lettersSpacing,
@@ -613,7 +613,7 @@ static void ListMenuPrint(struct ListMenu *list, const u8 *str, u8 x, u8 y)
         colors[0] = list->template.fillValue;
         colors[1] = list->template.cursorPal;
         colors[2] = list->template.cursorShadowPal;
-        AddTextPrinterParameterized2(list->template.windowId,
+        AddTextPrinterParameterized4(list->template.windowId,
                                      list->template.fontId,
                                      x, y,
                                      list->template.lettersSpacing,
diff --git a/src/mail.c b/src/mail.c
index 625b52de3..3c12bed3f 100644
--- a/src/mail.c
+++ b/src/mail.c
@@ -485,14 +485,14 @@ static void sub_8121B1C(void)
         {
             continue;
         }
-        box_print(0, 1, sMailRead->layout->var8[i].xOffset + sMailRead->layout->wordsYPos, y + sMailRead->layout->wordsXPos, sUnknown_0859F2AC, 0, sMailRead->strbuf[i]);
+        AddTextPrinterParameterized3(0, 1, sMailRead->layout->var8[i].xOffset + sMailRead->layout->wordsYPos, y + sMailRead->layout->wordsXPos, sUnknown_0859F2AC, 0, sMailRead->strbuf[i]);
         y += sMailRead->layout->var8[i].lineHeight;
     }
     bufptr = StringCopy(strbuf, gText_FromSpace);
     StringCopy(bufptr, sMailRead->playerName);
     box_x = GetStringCenterAlignXOffset(1, strbuf, sMailRead->signatureWidth) + 0x68;
     box_y = sMailRead->layout->signatureYPos + 0x58;
-    box_print(0, 1, box_x, box_y, sUnknown_0859F2AC, 0, strbuf);
+    AddTextPrinterParameterized3(0, 1, box_x, box_y, sUnknown_0859F2AC, 0, strbuf);
     CopyWindowToVram(0, 3);
     CopyWindowToVram(1, 3);
 }
diff --git a/src/main_menu.c b/src/main_menu.c
index 314ac272a..fd8b1b04d 100644
--- a/src/main_menu.c
+++ b/src/main_menu.c
@@ -649,8 +649,8 @@ void Task_DisplayMainMenu(u8 taskId)
             default:
                 FillWindowPixelBuffer(0, 0xAA);
                 FillWindowPixelBuffer(1, 0xAA);
-                box_print(0, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
-                box_print(1, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
+                AddTextPrinterParameterized3(0, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
+                AddTextPrinterParameterized3(1, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
                 PutWindowTilemap(0);
                 PutWindowTilemap(1);
                 CopyWindowToVram(0, 2);
@@ -662,9 +662,9 @@ void Task_DisplayMainMenu(u8 taskId)
                 FillWindowPixelBuffer(2, 0xAA);
                 FillWindowPixelBuffer(3, 0xAA);
                 FillWindowPixelBuffer(4, 0xAA);
-                box_print(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
-                box_print(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
-                box_print(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
+                AddTextPrinterParameterized3(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
+                AddTextPrinterParameterized3(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
+                AddTextPrinterParameterized3(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
                 fmt_savegame();
                 PutWindowTilemap(2);
                 PutWindowTilemap(3);
@@ -681,10 +681,10 @@ void Task_DisplayMainMenu(u8 taskId)
                 FillWindowPixelBuffer(3, 0xAA);
                 FillWindowPixelBuffer(4, 0xAA);
                 FillWindowPixelBuffer(5, 0xAA);
-                box_print(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
-                box_print(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
-                box_print(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryGift);
-                box_print(5, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
+                AddTextPrinterParameterized3(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
+                AddTextPrinterParameterized3(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
+                AddTextPrinterParameterized3(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryGift);
+                AddTextPrinterParameterized3(5, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
                 fmt_savegame();
                 PutWindowTilemap(2);
                 PutWindowTilemap(3);
@@ -705,11 +705,11 @@ void Task_DisplayMainMenu(u8 taskId)
                 FillWindowPixelBuffer(4, 0xAA);
                 FillWindowPixelBuffer(5, 0xAA);
                 FillWindowPixelBuffer(6, 0xAA);
-                box_print(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
-                box_print(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
-                box_print(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryGift2);
-                box_print(5, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryEvents);
-                box_print(6, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
+                AddTextPrinterParameterized3(2, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuContinue);
+                AddTextPrinterParameterized3(3, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuNewGame);
+                AddTextPrinterParameterized3(4, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryGift2);
+                AddTextPrinterParameterized3(5, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuMysteryEvents);
+                AddTextPrinterParameterized3(6, 1, 0, 1, gTextColor_Headers, -1, gText_MainMenuOption);
                 fmt_savegame();
                 PutWindowTilemap(2);
                 PutWindowTilemap(3);
@@ -1942,7 +1942,7 @@ void set_default_player_name(u8 nameId)
 void CreateMainMenuErrorWindow(const u8* str)
 {
     FillWindowPixelBuffer(7, 17);
-    PrintTextOnWindow(7, 1, str, 0, 1, 2, 0);
+    AddTextPrinterParameterized(7, 1, str, 0, 1, 2, 0);
     PutWindowTilemap(7);
     CopyWindowToVram(7, 2);
     DrawMainMenuWindowBorder(&sWindowTemplates_MainMenu[7], MAIN_MENU_BORDER_TILE);
@@ -1961,8 +1961,8 @@ void fmt_savegame(void)
 void fmt_time(void)
 {
     StringExpandPlaceholders(gStringVar4, gText_ContinueMenuPlayer);
-    box_print(2, 1, 0, 17, gUnknown_082FF0E3, -1, gStringVar4);
-    box_print(2, 1, GetStringRightAlignXOffset(1, gSaveBlock2Ptr->playerName, 100), 17, gUnknown_082FF0E3, -1, gSaveBlock2Ptr->playerName);
+    AddTextPrinterParameterized3(2, 1, 0, 17, gUnknown_082FF0E3, -1, gStringVar4);
+    AddTextPrinterParameterized3(2, 1, GetStringRightAlignXOffset(1, gSaveBlock2Ptr->playerName, 100), 17, gUnknown_082FF0E3, -1, gSaveBlock2Ptr->playerName);
 }
 
 void fmt_player(void)
@@ -1971,11 +1971,11 @@ void fmt_player(void)
     u8* ptr;
 
     StringExpandPlaceholders(gStringVar4, gText_ContinueMenuTime);
-    box_print(2, 1, 0x6C, 17, gUnknown_082FF0E3, -1, gStringVar4);
+    AddTextPrinterParameterized3(2, 1, 0x6C, 17, gUnknown_082FF0E3, -1, gStringVar4);
     ptr = ConvertIntToDecimalStringN(str, gSaveBlock2Ptr->playTimeHours, 0, 3);
     *ptr = 0xF0;
     ConvertIntToDecimalStringN(ptr + 1, gSaveBlock2Ptr->playTimeMinutes, 2, 2);
-    box_print(2, 1, GetStringRightAlignXOffset(1, str, 0xD0), 17, gUnknown_082FF0E3, -1, str);
+    AddTextPrinterParameterized3(2, 1, GetStringRightAlignXOffset(1, str, 0xD0), 17, gUnknown_082FF0E3, -1, str);
 }
 
 void fmt_pokedex(void)
@@ -1990,9 +1990,9 @@ void fmt_pokedex(void)
         else
             dexCount = GetHoennPokedexCount(1);
         StringExpandPlaceholders(gStringVar4, gText_ContinueMenuPokedex);
-        box_print(2, 1, 0, 33, gUnknown_082FF0E3, -1, gStringVar4);
+        AddTextPrinterParameterized3(2, 1, 0, 33, gUnknown_082FF0E3, -1, gStringVar4);
         ConvertIntToDecimalStringN(str, dexCount, 0, 3);
-        box_print(2, 1, GetStringRightAlignXOffset(1, str, 100), 33, gUnknown_082FF0E3, -1, str);
+        AddTextPrinterParameterized3(2, 1, GetStringRightAlignXOffset(1, str, 100), 33, gUnknown_082FF0E3, -1, str);
     }
 }
 
@@ -2008,9 +2008,9 @@ void fmt_badges(void)
             badgeCount++;
     }
     StringExpandPlaceholders(gStringVar4, gText_ContinueMenuBadges);
-    box_print(2, 1, 0x6C, 33, gUnknown_082FF0E3, -1, gStringVar4);
+    AddTextPrinterParameterized3(2, 1, 0x6C, 33, gUnknown_082FF0E3, -1, gStringVar4);
     ConvertIntToDecimalStringN(str, badgeCount, 2, 1);
-    box_print(2, 1, GetStringRightAlignXOffset(1, str, 0xD0), 33, gUnknown_082FF0E3, -1, str);
+    AddTextPrinterParameterized3(2, 1, GetStringRightAlignXOffset(1, str, 0xD0), 33, gUnknown_082FF0E3, -1, str);
 }
 
 void LoadMainMenuWindowFrameTiles(u8 bgId, u16 tileOffset)
diff --git a/src/map_name_popup.c b/src/map_name_popup.c
index 0d22bd126..3feffd70d 100644
--- a/src/map_name_popup.c
+++ b/src/map_name_popup.c
@@ -329,7 +329,7 @@ static void ShowMapNamePopUpWindow(void)
     mapDisplayHeader[0] = EXT_CTRL_CODE_BEGIN;
     mapDisplayHeader[1] = EXT_CTRL_CODE_HIGHLIGHT;
     mapDisplayHeader[2] = TEXT_COLOR_TRANSPARENT;
-    PrintTextOnWindow(GetMapNamePopUpWindowId(), 7, mapDisplayHeader, x, 3, 0xFF, NULL);
+    AddTextPrinterParameterized(GetMapNamePopUpWindowId(), 7, mapDisplayHeader, x, 3, 0xFF, NULL);
     CopyWindowToVram(GetMapNamePopUpWindowId(), 3);
 }
 
diff --git a/src/mauville_old_man.c b/src/mauville_old_man.c
index 591e3ad9a..6ebc7affa 100644
--- a/src/mauville_old_man.c
+++ b/src/mauville_old_man.c
@@ -438,7 +438,7 @@ static void BardSong_TextSubPrinter(struct TextSubPrinter * printer, u16 a1)
 static void sub_8120708(const u8 * src)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, src, 0, 1, 1, BardSong_TextSubPrinter);
+    AddTextPrinterParameterized(0, 1, src, 0, 1, 1, BardSong_TextSubPrinter);
     gUnknown_03002F84 = TRUE;
     CopyWindowToVram(0, 3);
 }
@@ -1160,9 +1160,9 @@ static void PrintStoryList(void)
         u16 gameStatID = sStorytellerPtr->gameStatIDs[i];
         if (gameStatID == 0)
             break;
-        PrintTextOnWindow(sStorytellerWindowId, 1, GetStoryTitleByStat(gameStatID), 8, 16 * i + 1, 0xFF, NULL);
+        AddTextPrinterParameterized(sStorytellerWindowId, 1, GetStoryTitleByStat(gameStatID), 8, 16 * i + 1, 0xFF, NULL);
     }
-    PrintTextOnWindow(sStorytellerWindowId, 1, gText_Exit, 8, 16 * i + 1, 0xFF, NULL);
+    AddTextPrinterParameterized(sStorytellerWindowId, 1, gText_Exit, 8, 16 * i + 1, 0xFF, NULL);
     InitMenuInUpperLeftCornerPlaySoundWhenAPressed(sStorytellerWindowId, GetFreeStorySlot() + 1, 0);
     CopyWindowToVram(sStorytellerWindowId, 3);
 }
diff --git a/src/menu.c b/src/menu.c
index 3acb44985..c5d70f555 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -163,7 +163,7 @@ u16 sub_8197224(void)
     return IsTextPrinterActive(0);
 }
 
-u16 AddTextPrinterParameterized(u8 windowId, u8 fontId, const u8 *str, u8 speed, void (*callback)(struct TextSubPrinter *, u16), u8 fgColor, u8 bgColor, u8 shadowColor)
+u16 AddTextPrinterParameterized2(u8 windowId, u8 fontId, const u8 *str, u8 speed, void (*callback)(struct TextSubPrinter *, u16), u8 fgColor, u8 bgColor, u8 shadowColor)
 {
     struct TextSubPrinter printer;
 
@@ -189,19 +189,19 @@ void AddTextPrinterForMessage(bool8 allowSkippingDelayWithButtonPress)
 {
     void (*callback)(struct TextSubPrinter *, u16) = NULL;
     gTextFlags.flag_0 = allowSkippingDelayWithButtonPress;
-    AddTextPrinterParameterized(0, 1, gStringVar4, GetPlayerTextSpeed(), callback, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, GetPlayerTextSpeed(), callback, 2, 1, 3);
 }
 
 void AddTextPrinterForMessage_2(bool8 allowSkippingDelayWithButtonPress)
 {
     gTextFlags.flag_0 = allowSkippingDelayWithButtonPress;
-    AddTextPrinterParameterized(0, 1, gStringVar4, GetPlayerTextSpeed(), NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, GetPlayerTextSpeed(), NULL, 2, 1, 3);
 }
 
 void AddTextPrinterWithCustomSpeedForMessage(bool8 allowSkippingDelayWithButtonPress, u8 speed)
 {
     gTextFlags.flag_0 = allowSkippingDelayWithButtonPress;
-    AddTextPrinterParameterized(0, 1, gStringVar4, speed, NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, speed, NULL, 2, 1, 3);
 }
 
 void sub_81973A4(void)
@@ -539,7 +539,7 @@ void RemoveMapNamePopUpWindow(void)
 void AddTextPrinterWithCallbackForMessage(bool8 a1, void (*callback)(struct TextSubPrinter *, u16))
 {
     gTextFlags.flag_0 = a1;
-    AddTextPrinterParameterized(0, 1, gStringVar4, GetPlayerTextSpeed(), callback, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, GetPlayerTextSpeed(), callback, 2, 1, 3);
 }
 
 void sub_8197AE8(bool8 copyToVram)
@@ -813,7 +813,7 @@ void sub_8198180(const u8 *string, u8 a2, bool8 copyToVram)
         PutWindowTilemap(gUnknown_0203CDA0);
         FillWindowPixelBuffer(gUnknown_0203CDA0, 0xFF);
         width = GetStringWidth(0, string, 0);
-        box_print(gUnknown_0203CDA0,
+        AddTextPrinterParameterized3(gUnknown_0203CDA0,
                   0,
                   0xEC - (GetWindowAttribute(gUnknown_0203CDA0, WINDOW_TILEMAP_LEFT) * 8) - a2 - width,
                   1,
@@ -849,7 +849,7 @@ void sub_8198204(const u8 *string, const u8 *string2, u8 a3, u8 a4, bool8 copyTo
         if (string2 != NULL)
         {
             width = GetStringWidth(0, string2, 0);
-            box_print(gUnknown_0203CDA0,
+            AddTextPrinterParameterized3(gUnknown_0203CDA0,
                       0,
                       0xEC - (GetWindowAttribute(gUnknown_0203CDA0, WINDOW_TILEMAP_LEFT) * 8) - a4 - width,
                       1,
@@ -857,7 +857,7 @@ void sub_8198204(const u8 *string, const u8 *string2, u8 a3, u8 a4, bool8 copyTo
                       0,
                       string2);
         }
-        AddTextPrinterParameterized2(gUnknown_0203CDA0, 1, 4, 1, 0, 0, color, 0, string);
+        AddTextPrinterParameterized4(gUnknown_0203CDA0, 1, 4, 1, 0, 0, color, 0, string);
         if (copyToVram)
             CopyWindowToVram(gUnknown_0203CDA0, 3);
     }
@@ -932,7 +932,7 @@ void RedrawMenuCursor(u8 oldPos, u8 newPos)
     width = GetMenuCursorDimensionByFont(gUnknown_0203CD90.fontId, 0);
     height = GetMenuCursorDimensionByFont(gUnknown_0203CD90.fontId, 1);
     FillWindowPixelRect(gUnknown_0203CD90.windowId, 0x11, gUnknown_0203CD90.left, gUnknown_0203CD90.optionHeight * oldPos + gUnknown_0203CD90.top, width, height);
-    PrintTextOnWindow(gUnknown_0203CD90.windowId, gUnknown_0203CD90.fontId, gText_SelectorArrow3, gUnknown_0203CD90.left, gUnknown_0203CD90.optionHeight * newPos + gUnknown_0203CD90.top, 0, 0);
+    AddTextPrinterParameterized(gUnknown_0203CD90.windowId, gUnknown_0203CD90.fontId, gText_SelectorArrow3, gUnknown_0203CD90.left, gUnknown_0203CD90.optionHeight * newPos + gUnknown_0203CD90.top, 0, 0);
 }
 
 u8 MoveMenuCursor(s8 cursorDelta)
@@ -1093,7 +1093,7 @@ void PrintTextArray(u8 windowId, u8 fontId, u8 left, u8 top, u8 lineHeight, u8 i
     u8 i;
     for (i = 0; i < itemCount; i++)
     {
-        PrintTextOnWindow(windowId, fontId, strs[i].text, left, (lineHeight * i) + top, 0xFF, NULL);
+        AddTextPrinterParameterized(windowId, fontId, strs[i].text, left, (lineHeight * i) + top, 0xFF, NULL);
     }
     CopyWindowToVram(windowId, 2);
 }
@@ -1103,7 +1103,7 @@ void sub_81987BC(u8 windowId, u8 fontId, u8 left, u8 top, u8 lineHeight, u8 item
     u8 i;
     for (i = 0; i < itemCount; i++)
     {
-        sub_8199F74(windowId, fontId, strs[i].text, left, (lineHeight * i) + top, 0xFF, NULL, a6, a7);
+        AddTextPrinterParameterized5(windowId, fontId, strs[i].text, left, (lineHeight * i) + top, 0xFF, NULL, a6, a7);
     }
     CopyWindowToVram(windowId, 2);
 }
@@ -1223,7 +1223,7 @@ void sub_8198C94(u8 windowId, u8 fontId, u8 left, u8 top, u8 a4, u8 a5, u8 a6, u
     {
         for (j = 0; j < a6; j++)
         {
-            PrintTextOnWindow(windowId, fontId, strs[(i * a6) + j].text, (a4 * j) + left, (a5 * i) + top, 0xFF, NULL);
+            AddTextPrinterParameterized(windowId, fontId, strs[(i * a6) + j].text, (a4 * j) + left, (a5 * i) + top, 0xFF, NULL);
         }
     }
     CopyWindowToVram(windowId, 2);
@@ -1317,7 +1317,7 @@ void sub_8199060(u8 oldCursorPos, u8 newCursorPos)
                         cursorHeight);
     xPos = (newCursorPos % gUnknown_0203CD90.horizontalCount) * gUnknown_0203CD90.optionWidth + gUnknown_0203CD90.left;
     yPos = (newCursorPos / gUnknown_0203CD90.horizontalCount) * gUnknown_0203CD90.optionHeight + gUnknown_0203CD90.top;
-    PrintTextOnWindow(gUnknown_0203CD90.windowId,
+    AddTextPrinterParameterized(gUnknown_0203CD90.windowId,
                       gUnknown_0203CD90.fontId,
                       gText_SelectorArrow3,
                       xPos,
@@ -1602,7 +1602,7 @@ void PrintMenuTable(u8 windowId, u8 itemCount, const struct MenuAction *strs)
 
     for (i = 0; i < itemCount; i++)
     {
-        PrintTextOnWindow(windowId, 1, strs[i].text, 8, (i * 16) + 1, 0xFF, NULL);
+        AddTextPrinterParameterized(windowId, 1, strs[i].text, 8, (i * 16) + 1, 0xFF, NULL);
     }
 
     CopyWindowToVram(windowId, 2);
@@ -1668,7 +1668,7 @@ void sub_81997AC(u8 windowId, u8 a4, u8 a6, u8 a7, const struct MenuAction *strs
     {
         for (j = 0; j < a6; j++)
         {
-            PrintTextOnWindow(windowId, 1, strs[(i * a6) + j].text, (a4 * j) + 8, (i * 16) + 1, 0xFF, NULL);
+            AddTextPrinterParameterized(windowId, 1, strs[(i * a6) + j].text, (a4 * j) + 8, (i * 16) + 1, 0xFF, NULL);
         }
     }
     CopyWindowToVram(windowId, 2);
@@ -1939,7 +1939,7 @@ void sub_8199DF0(u32 bg, u8 a1, int a2, int a3)
     RequestDma3Fill(a1 << 24 | a1 << 16 | a1 << 8 | a1, addr + VRAM, a3 * temp, 1);
 }
 
-void box_print(u8 windowId, u8 fontId, u8 left, u8 top, const u8 *color, s8 speed, const u8 *str)
+void AddTextPrinterParameterized3(u8 windowId, u8 fontId, u8 left, u8 top, const u8 *color, s8 speed, const u8 *str)
 {
     struct TextSubPrinter printer;
 
@@ -1960,7 +1960,7 @@ void box_print(u8 windowId, u8 fontId, u8 left, u8 top, const u8 *color, s8 spee
     AddTextPrinter(&printer, speed, NULL);
 }
 
-void AddTextPrinterParameterized2(u8 windowId, u8 fontId, u8 left, u8 top, u8 letterSpacing, u8 lineSpacing, const u8 *color, s8 speed, const u8 *str)
+void AddTextPrinterParameterized4(u8 windowId, u8 fontId, u8 left, u8 top, u8 letterSpacing, u8 lineSpacing, const u8 *color, s8 speed, const u8 *str)
 {
     struct TextSubPrinter printer;
 
@@ -1981,7 +1981,7 @@ void AddTextPrinterParameterized2(u8 windowId, u8 fontId, u8 left, u8 top, u8 le
     AddTextPrinter(&printer, speed, NULL);
 }
 
-void sub_8199F74(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 speed, void (*callback)(struct TextSubPrinter *, u16), u8 letterSpacing, u8 lineSpacing)
+void AddTextPrinterParameterized5(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 speed, void (*callback)(struct TextSubPrinter *, u16), u8 letterSpacing, u8 lineSpacing)
 {
     struct TextSubPrinter printer;
 
@@ -2011,7 +2011,7 @@ void PrintPlayerNameOnWindow(u8 windowId, const u8 *src, u16 x, u16 y)
 
     StringExpandPlaceholders(gStringVar4, src);
 
-    PrintTextOnWindow(windowId, 1, gStringVar4, x, y, 0xFF, 0);
+    AddTextPrinterParameterized(windowId, 1, gStringVar4, x, y, 0xFF, 0);
 }
 
 //Screw this function, it's long and unreferenced and ugh
diff --git a/src/menu_helpers.c b/src/menu_helpers.c
index 217fdabae..0f6d5aa38 100644
--- a/src/menu_helpers.c
+++ b/src/menu_helpers.c
@@ -137,7 +137,7 @@ void DisplayMessageAndContinueTask(u8 taskId, u8 windowId, u16 arg2, u8 arg3, u8
         StringExpandPlaceholders(gStringVar4, string);
 
     gTextFlags.flag_0 = 1;
-    AddTextPrinterParameterized(windowId, fontId, gStringVar4, textSpeed, NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(windowId, fontId, gStringVar4, textSpeed, NULL, 2, 1, 3);
     gUnknown_0300117C = taskFunc;
     gTasks[taskId].func = Task_ContinueTaskAfterMessagePrints;
 }
diff --git a/src/money.c b/src/money.c
index 98f25a42a..7b78dda92 100644
--- a/src/money.c
+++ b/src/money.c
@@ -152,7 +152,7 @@ void PrintMoneyAmount(u8 windowId, u8 x, u8 y, int amount, u8 speed)
         *(txtPtr++) = 0x77;
 
     StringExpandPlaceholders(txtPtr, gText_PokedollarVar1);
-    PrintTextOnWindow(windowId, 1, gStringVar4, x, y, speed, NULL);
+    AddTextPrinterParameterized(windowId, 1, gStringVar4, x, y, speed, NULL);
 }
 
 void PrintMoneyAmountInMoneyBoxWithBorder(u8 windowId, u16 tileStart, u8 pallete, int amount)
diff --git a/src/mystery_event_menu.c b/src/mystery_event_menu.c
index 7f031c704..8dcb960b7 100644
--- a/src/mystery_event_menu.c
+++ b/src/mystery_event_menu.c
@@ -314,5 +314,5 @@ static void PrintMysteryMenuText(u8 windowId, const u8 *text, u8 x, u8 y, s32 sp
     textColor[2] = 3;
 
     FillWindowPixelBuffer(windowId, (textColor[0]) | (textColor[0] << 4));
-    AddTextPrinterParameterized2(windowId, 1, x, y, letterSpacing, lineSpacing, textColor, speed, text);
+    AddTextPrinterParameterized4(windowId, 1, x, y, letterSpacing, lineSpacing, textColor, speed, text);
 }
diff --git a/src/naming_screen.c b/src/naming_screen.c
index 42525380b..4d4178c7a 100644
--- a/src/naming_screen.c
+++ b/src/naming_screen.c
@@ -572,7 +572,7 @@ static void DisplaySentToPCMessage(void)
     StringExpandPlaceholders(gStringVar4, gUnknown_0858BDB8[stringToDisplay]);
     NewMenuHelpers_DrawDialogueFrame(0, 0);
     gTextFlags.flag_0 = TRUE;
-    AddTextPrinterParameterized(0, 1, gStringVar4, GetPlayerTextSpeed(), 0, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, GetPlayerTextSpeed(), 0, 2, 1, 3);
     CopyWindowToVram(0, 3);
 }
 
@@ -1488,7 +1488,7 @@ static void HandleDpadMovement(struct Task *task)
 static void sub_80E4894(void)
 {
     FillWindowPixelBuffer(gNamingScreenData->windows[3], 0x11);
-    PrintTextOnWindow(gNamingScreenData->windows[3], 1, gNamingScreenData->template->title, 8, 1, 0, 0);
+    AddTextPrinterParameterized(gNamingScreenData->windows[3], 1, gNamingScreenData->template->title, 8, 1, 0, 0);
     PutWindowTilemap(gNamingScreenData->windows[3]);
 }
 
@@ -1499,7 +1499,7 @@ static void sub_80E48E8(void)
     StringCopy(buffer, gSpeciesNames[gNamingScreenData->monSpecies]);
     StringAppendN(buffer, gNamingScreenData->template->title, 15);
     FillWindowPixelBuffer(gNamingScreenData->windows[3], 0x11);
-    PrintTextOnWindow(gNamingScreenData->windows[3], 1, buffer, 8, 1, 0, 0);
+    AddTextPrinterParameterized(gNamingScreenData->windows[3], 1, buffer, 8, 1, 0, 0);
     PutWindowTilemap(gNamingScreenData->windows[3]);
 }
 
@@ -1556,7 +1556,7 @@ static void sub_80E49BC(void)
             StringCopy(genderSymbol, gText_FemaleSymbol);
             isFemale = TRUE;
         }
-        box_print(gNamingScreenData->windows[2], 1, 0x68, 1, sGenderColors[isFemale], -1, genderSymbol);
+        AddTextPrinterParameterized3(gNamingScreenData->windows[2], 1, 0x68, 1, sGenderColors[isFemale], -1, genderSymbol);
     }
 }
 
@@ -1693,7 +1693,7 @@ static void sub_80E4D10(void)
         temp[1] = gExpandedPlaceholder_Empty[0];
         unk2 = (sub_80E503C(temp[0]) == 1) ? 2 : 0;
 
-        PrintTextOnWindow(gNamingScreenData->windows[2], 1, temp, i * 8 + unk + unk2, 1, 0xFF, NULL);
+        AddTextPrinterParameterized(gNamingScreenData->windows[2], 1, temp, i * 8 + unk + unk2, 1, 0xFF, NULL);
     }
 
     sub_80E498C();
@@ -1735,7 +1735,7 @@ static void sub_80E4DE4(u8 window, u8 a1)
 
     for (i = 0; i < 4; i++)
     {
-        box_print(window, 1, 0, i * 16 + 1, sUnkColors[a1], 0, gUnknown_0858C198[a1][i]);
+        AddTextPrinterParameterized3(window, 1, 0, i * 16 + 1, sUnkColors[a1], 0, gUnknown_0858C198[a1][i]);
     }
 
     PutWindowTilemap(window);
@@ -1780,7 +1780,7 @@ static void sub_80E4EF0(void)
     const u8 color[3] = { 15, 1, 2 };
 
     FillWindowPixelBuffer(gNamingScreenData->windows[4], 0xFF);
-    box_print(gNamingScreenData->windows[4], 0, 2, 1, color, 0, gText_MoveOkBack);
+    AddTextPrinterParameterized3(gNamingScreenData->windows[4], 0, 2, 1, color, 0, gText_MoveOkBack);
     PutWindowTilemap(gNamingScreenData->windows[4]);
     CopyWindowToVram(gNamingScreenData->windows[4], 3);
 }
diff --git a/src/option_menu.c b/src/option_menu.c
index d48a1e448..6cb208c63 100644
--- a/src/option_menu.c
+++ b/src/option_menu.c
@@ -395,7 +395,7 @@ static void DrawOptionMenuChoice(const u8 *text, u8 x, u8 y, u8 style)
     }
 
     dst[i] = EOS;
-    PrintTextOnWindow(WIN_OPTIONS, 1, dst, x, y + 1, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(WIN_OPTIONS, 1, dst, x, y + 1, TEXT_SPEED_FF, NULL);
 }
 
 static u8 TextSpeed_ProcessInput(u8 selection)
@@ -621,7 +621,7 @@ static void ButtonMode_DrawChoices(u8 selection)
 static void DrawTextOption(void)
 {
     FillWindowPixelBuffer(WIN_TEXT_OPTION, 0x11);
-    PrintTextOnWindow(WIN_TEXT_OPTION, 1, gText_Option, 8, 1, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(WIN_TEXT_OPTION, 1, gText_Option, 8, 1, TEXT_SPEED_FF, NULL);
     CopyWindowToVram(WIN_TEXT_OPTION, 3);
 }
 
@@ -632,7 +632,7 @@ static void DrawOptionMenuTexts(void)
     FillWindowPixelBuffer(WIN_OPTIONS, 0x11);
     for (i = 0; i < MENUITEM_COUNT; i++)
     {
-        PrintTextOnWindow(WIN_OPTIONS, 1, sOptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL);
+        AddTextPrinterParameterized(WIN_OPTIONS, 1, sOptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL);
     }
     CopyWindowToVram(WIN_OPTIONS, 3);
 }
diff --git a/src/player_pc.c b/src/player_pc.c
index 7ac8e78d5..bdbef1b43 100644
--- a/src/player_pc.c
+++ b/src/player_pc.c
@@ -453,7 +453,7 @@ static void InitItemStorageMenu(u8 taskId, u8 var)
 static void ItemStorageMenuPrint(const u8 *textPtr)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, textPtr, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, textPtr, 0, 1, 0, 0);
 }
 
 static void ItemStorageMenuProcessInput(u8 taskId)
@@ -626,7 +626,7 @@ static void Mailbox_DrawMailboxMenu(u8 taskId)
 
     windowId = sub_81D1C84(0);
     sub_81D1C84(1);
-    PrintTextOnWindow(windowId, 1, gText_Mailbox, GetStringCenterAlignXOffset(1, gText_Mailbox, 0x40), 1, 0, NULL);
+    AddTextPrinterParameterized(windowId, 1, gText_Mailbox, GetStringCenterAlignXOffset(1, gText_Mailbox, 0x40), 1, 0, NULL);
     schedule_bg_copy_tilemap_to_vram(0);
     gTasks[taskId].data[5] = sub_81D1DC0(&playerPCItemPageInfo);
     sub_81D1E90(&playerPCItemPageInfo);
@@ -965,7 +965,7 @@ static void fish4_goto_x5_or_x6(u8 windowId, s32 id, u8 yOffset)
         }
         ConvertIntToDecimalStringN(gStringVar1, gSaveBlock1Ptr->pcItems[id].quantity, STR_CONV_MODE_RIGHT_ALIGN, 3);
         StringExpandPlaceholders(gStringVar4, gText_xVar1);
-        PrintTextOnWindow(windowId, 7, gStringVar4, GetStringRightAlignXOffset(7, gStringVar4, 104), yOffset, 0xFF, NULL);
+        AddTextPrinterParameterized(windowId, 7, gStringVar4, GetStringRightAlignXOffset(7, gStringVar4, 104), yOffset, 0xFF, NULL);
     }
 }
 
@@ -979,7 +979,7 @@ static void sub_816BEF0(s32 id)
     else
         description = ItemStorage_GetItemPcResponse(ITEMPC_GO_BACK_TO_PREV);
     FillWindowPixelBuffer(windowId, 17);
-    PrintTextOnWindow(windowId, 1, description, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(windowId, 1, description, 0, 1, 0, NULL);
 }
 
 static void ItemStorage_StartScrollIndicator(void)
@@ -1008,7 +1008,7 @@ static void sub_816BFE0(u8 y, u8 b, u8 speed)
     if(b == 0xFF)
         FillWindowPixelRect(windowId, 17, 0, y, GetMenuCursorDimensionByFont(1, 0), GetMenuCursorDimensionByFont(1, 1));
     else
-        AddTextPrinterParameterized2(windowId, 1, 0, y, 0, 0, gUnknown_085DFF8C, speed, gText_SelectorArrow2);
+        AddTextPrinterParameterized4(windowId, 1, 0, y, 0, 0, gUnknown_085DFF8C, speed, gText_SelectorArrow2);
 }
 
 static void sub_816C060(u16 itemId)
@@ -1070,7 +1070,7 @@ static void ItemStorage_ProcessWithdrawTossInput(u8 taskId)
     if(!toss)
         text = gText_WithdrawItem;
     x = GetStringCenterAlignXOffset(1, text, 104);
-    PrintTextOnWindow(gUnknown_0203BCC4->windowIds[3], 1, text, x, 1, 0, NULL);
+    AddTextPrinterParameterized(gUnknown_0203BCC4->windowIds[3], 1, text, x, 1, 0, NULL);
     CopyWindowToVram(gUnknown_0203BCC4->windowIds[2], 2);
     sub_816C110();
     sub_816C140();
@@ -1126,7 +1126,7 @@ static void ItemStorage_PrintItemPcResponse(const u8 *string)
     u8 windowId = gUnknown_0203BCC4->windowIds[1];
     FillWindowPixelBuffer(windowId, 0x11);
     StringExpandPlaceholders(gStringVar4, string);
-    PrintTextOnWindow(windowId, 1, gStringVar4, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(windowId, 1, gStringVar4, 0, 1, 0, NULL);
 }
 
 static void ItemStorage_ProcessInput(u8 taskId)
@@ -1284,7 +1284,7 @@ static void sub_816C6BC(u8 windowId, u16 value, u32 mode, u8 x, u8 y, u8 n)
 {
     ConvertIntToDecimalStringN(gStringVar1, value, mode, n);
     StringExpandPlaceholders(gStringVar4, gText_xVar1);
-    PrintTextOnWindow(windowId, 1, gStringVar4, GetStringCenterAlignXOffset(1, gStringVar4, 48), y, 0, NULL);
+    AddTextPrinterParameterized(windowId, 1, gStringVar4, GetStringCenterAlignXOffset(1, gStringVar4, 48), y, 0, NULL);
 }
 
 static void ItemStorage_DoItemAction(u8 taskId)
diff --git a/src/pokeblock.c b/src/pokeblock.c
index 0fa2cde04..d0a867b3a 100644
--- a/src/pokeblock.c
+++ b/src/pokeblock.c
@@ -677,7 +677,7 @@ static void HandleInitWindows(void)
 
 static void PrintOnPokeblockWindow(u8 windowId, const u8 *string, s32 x)
 {
-    AddTextPrinterParameterized2(windowId, 1, x, 1, 0, 0, sTextColorInPokeblockMenu, 0, string);
+    AddTextPrinterParameterized4(windowId, 1, x, 1, 0, 0, sTextColorInPokeblockMenu, 0, string);
 }
 
 static void PutPokeblockInfoText(void)
diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c
index 5f06ed7e8..1449d4a00 100644
--- a/src/pokeblock_feed.c
+++ b/src/pokeblock_feed.c
@@ -789,7 +789,7 @@ static void Task_HandleMonAtePokeblock(u8 taskId)
         StringExpandPlaceholders(gStringVar4, gText_Var1DisdainfullyAteVar2);
 
     gTextFlags.flag_0 = 1;
-    AddTextPrinterParameterized(0, 1, gStringVar4, GetPlayerTextSpeed(), NULL, 2, 1, 3);
+    AddTextPrinterParameterized2(0, 1, gStringVar4, GetPlayerTextSpeed(), NULL, 2, 1, 3);
     gTasks[taskId].func = Task_WaitForAtePokeblockText;
 }
 
diff --git a/src/pokedex.c b/src/pokedex.c
index 2cb3c153f..d27f0d89c 100644
--- a/src/pokedex.c
+++ b/src/pokedex.c
@@ -1637,7 +1637,7 @@ void sub_80BCE2C(u8 windowId, u8 fontId, const u8* str, u8 left, u8 top)
     color[0] = 0;
     color[1] = 15;
     color[2] = 3;
-    AddTextPrinterParameterized2(windowId, fontId, left * 8, (top * 8) + 1, 0, 0, color, -1, str);
+    AddTextPrinterParameterized4(windowId, fontId, left * 8, (top * 8) + 1, 0, 0, color, -1, str);
 }
 
 void sub_80BCE84(u8 a, u16 b, u16 c)
@@ -2450,7 +2450,7 @@ void sub_80BE8DC(const u8* str, u8 left, u8 top)
     color[1] = 15;
     color[2] = 3;
 
-    AddTextPrinterParameterized2(0, 1, left, top, 0, 0, color, -1, str);
+    AddTextPrinterParameterized4(0, 1, left, top, 0, 0, color, -1, str);
 }
 
 u8 sub_80BE91C(struct PokedexListItem* item, u8 b)
@@ -4065,7 +4065,7 @@ void sub_80C0A88(u8 windowId, const u8 *str, u8 left, u8 top)
     color[1] = 15;
     color[2] = 3;
 
-    AddTextPrinterParameterized2(windowId, 1, left, top, 0, 0, color, -1, str);
+    AddTextPrinterParameterized4(windowId, 1, left, top, 0, 0, color, -1, str);
 }
 
 void sub_80C0AC4(u8 windowId, u16 order, u8 left, u8 top)
@@ -4368,7 +4368,7 @@ void sub_80C1270(const u8 *str, u32 left, u32 top)
     color[0] = 0;
     color[1] = 15;
     color[2] = 2;
-    AddTextPrinterParameterized2(0, 1, left, top, 0, 0, color, -1, str);
+    AddTextPrinterParameterized4(0, 1, left, top, 0, 0, color, -1, str);
 }
 
 void sub_80C12B0(u32 x, u32 y, u32 width, u32 height)
diff --git a/src/pokemon_storage_system.c b/src/pokemon_storage_system.c
index 7c622c223..031f704a4 100644
--- a/src/pokemon_storage_system.c
+++ b/src/pokemon_storage_system.c
@@ -258,7 +258,7 @@ void Task_PokemonStorageSystem(u8 taskId)
         sub_81973A4();
         NewMenuHelpers_DrawDialogueFrame(0, 0);
         FillWindowPixelBuffer(0, 0x11);
-        AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, TEXT_SPEED_FF, NULL, 2, 1, 3);
+        AddTextPrinterParameterized2(0, 1, gUnknown_085716C0[task->data[1]].desc, TEXT_SPEED_FF, NULL, 2, 1, 3);
         CopyWindowToVram(0, 3);
         CopyWindowToVram(task->data[15], 3);
         task->data[0]++;
@@ -284,7 +284,7 @@ void Task_PokemonStorageSystem(u8 taskId)
             {
                 task->data[1] = task->data[3];
                 FillWindowPixelBuffer(0, 0x11);
-                AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
             }
             break;
         case -1:
@@ -299,13 +299,13 @@ void Task_PokemonStorageSystem(u8 taskId)
             if (task->data[2] == 0 && CountPartyMons() == PARTY_SIZE)
             {
                 FillWindowPixelBuffer(0, 0x11);
-                AddTextPrinterParameterized(0, 1, gText_PartyFull, 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gText_PartyFull, 0, NULL, 2, 1, 3);
                 task->data[0] = 3;
             }
             else if (task->data[2] == 1 && CountPartyMons() == 1)
             {
                 FillWindowPixelBuffer(0, 0x11);
-                AddTextPrinterParameterized(0, 1, gText_JustOnePkmn, 0, NULL, 2, 1, 3);
+                AddTextPrinterParameterized2(0, 1, gText_JustOnePkmn, 0, NULL, 2, 1, 3);
                 task->data[0] = 3;
             }
             else
@@ -320,7 +320,7 @@ void Task_PokemonStorageSystem(u8 taskId)
         if (gMain.newKeys & (A_BUTTON | B_BUTTON))
         {
             FillWindowPixelBuffer(0, 0x11);
-            AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+            AddTextPrinterParameterized2(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
             task->data[0] = 2;
         }
         else if (gMain.newKeys & DPAD_UP)
@@ -330,7 +330,7 @@ void Task_PokemonStorageSystem(u8 taskId)
             MoveMenuCursor(-1);
             task->data[1] = GetMenuCursorPos();
             FillWindowPixelBuffer(0, 0x11);
-            AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+            AddTextPrinterParameterized2(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
             task->data[0] = 2;
         }
         else if (gMain.newKeys & DPAD_DOWN)
@@ -340,7 +340,7 @@ void Task_PokemonStorageSystem(u8 taskId)
             MoveMenuCursor(1);
             task->data[1] = GetMenuCursorPos();
             FillWindowPixelBuffer(0, 0x11);
-            AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+            AddTextPrinterParameterized2(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
             task->data[0] = 2;
         }
         break;
@@ -627,12 +627,12 @@ void sub_80C7BE4(void)
     FillWindowPixelBuffer(windowId, 0x44);
 
     center = GetStringCenterAlignXOffset(1, boxName, 0x40);
-    box_print(windowId, 1, center, 1, gUnknown_08571734, TEXT_SPEED_FF, boxName);
+    AddTextPrinterParameterized3(windowId, 1, center, 1, gUnknown_08571734, TEXT_SPEED_FF, boxName);
 
     ConvertIntToDecimalStringN(text, nPokemonInBox, 1, 2);
     StringAppend(text, gUnknown_08571737);
     center = GetStringCenterAlignXOffset(1, text, 0x40);
-    box_print(windowId, 1, center, 0x11, gUnknown_08571734, TEXT_SPEED_FF, text);
+    AddTextPrinterParameterized3(windowId, 1, center, 0x11, gUnknown_08571734, TEXT_SPEED_FF, text);
 
     winTileData = GetWindowAttribute(windowId, WINDOW_TILE_DATA);
     CpuCopy32((void *)winTileData, (void *)OBJ_VRAM0 + 0x100 + (GetSpriteTileStartByTag(gUnknown_02039D04->unk_0240) * 32), 0x400);
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index 6b51c6e07..df596749e 100644
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -2638,7 +2638,7 @@ static void sub_81C2554(void)
 
 static void SummaryScreen_PrintTextOnWindow(u8 windowId, const u8 *string, u8 x, u8 y, u8 lineSpacing, u8 colorId)
 {
-    AddTextPrinterParameterized2(windowId, 1, x, y, 0, lineSpacing, sTextColors_861CD2C[colorId], 0, string);
+    AddTextPrinterParameterized4(windowId, 1, x, y, 0, lineSpacing, sTextColors_861CD2C[colorId], 0, string);
 }
 
 static void sub_81C25E8(void)
diff --git a/src/record_mixing.c b/src/record_mixing.c
index 552c32d38..6c6f69fa8 100644
--- a/src/record_mixing.c
+++ b/src/record_mixing.c
@@ -306,7 +306,7 @@ static void ReceiveExchangePacket(u32 which)
 static void PrintTextOnRecordMixing(const u8 *src)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, src, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(0, 1, src, 0, 1, 0, NULL);
     CopyWindowToVram(0, 3);
 }
 
diff --git a/src/region_map.c b/src/region_map.c
index 3214ae185..e06d121e9 100644
--- a/src/region_map.c
+++ b/src/region_map.c
@@ -1631,7 +1631,7 @@ void MCB2_FlyMap(void)
             LoadPalette(sRegionMapFramePal, 0x10, 0x20);
             PutWindowTilemap(2);
             FillWindowPixelBuffer(2, 0x00);
-            PrintTextOnWindow(2, 1, gText_FlyToWhere, 0, 1, 0, NULL);
+            AddTextPrinterParameterized(2, 1, gText_FlyToWhere, 0, 1, 0, NULL);
             schedule_bg_copy_tilemap_to_vram(0);
             gMain.state++;
             break;
@@ -1697,9 +1697,9 @@ static void sub_8124904(void)
                     flag = TRUE;
                     sub_8198070(0, FALSE);
                     SetWindowBorderStyle(1, FALSE, 0x65, 0x0d);
-                    PrintTextOnWindow(1, 1, sFlyMap->regionMap.mapSecName, 0, 1, 0, NULL);
+                    AddTextPrinterParameterized(1, 1, sFlyMap->regionMap.mapSecName, 0, 1, 0, NULL);
                     name = gUnknown_085A1EDC[i].name[sFlyMap->regionMap.posWithinMapSec];
-                    PrintTextOnWindow(1, 1, name, GetStringRightAlignXOffset(1, name, 0x60), 0x11, 0, NULL);
+                    AddTextPrinterParameterized(1, 1, name, GetStringRightAlignXOffset(1, name, 0x60), 0x11, 0, NULL);
                     schedule_bg_copy_tilemap_to_vram(0);
                     gUnknown_03001180 = TRUE;
                 }
@@ -1717,7 +1717,7 @@ static void sub_8124904(void)
             {
                 FillWindowPixelBuffer(0, 0x11);
             }
-            PrintTextOnWindow(0, 1, sFlyMap->regionMap.mapSecName, 0, 1, 0, NULL);
+            AddTextPrinterParameterized(0, 1, sFlyMap->regionMap.mapSecName, 0, 1, 0, NULL);
             schedule_bg_copy_tilemap_to_vram(0);
             gUnknown_03001180 = FALSE;
         }
diff --git a/src/reset_rtc_screen.c b/src/reset_rtc_screen.c
index 416a8da9d..34444cbf4 100644
--- a/src/reset_rtc_screen.c
+++ b/src/reset_rtc_screen.c
@@ -314,14 +314,14 @@ static void PrintTime(u8 windowId, u8 x, u8 y, u16 days, u8 hours, u8 minutes, u
     ConvertIntToDecimalStringN(gStringVar1, seconds, 2, 2);
     dest = StringCopy(dest, gStringVar1);
 
-    PrintTextOnWindow(windowId, 1, gStringVar4, x, y, TEXT_SPEED_FF, NULL);
+    AddTextPrinterParameterized(windowId, 1, gStringVar4, x, y, TEXT_SPEED_FF, NULL);
 }
 
 static void ShowChooseTimeWindow(u8 windowId, u16 days, u8 hours, u8 minutes, u8 seconds)
 {
     SetWindowBorderStyle(windowId, FALSE, 0x214, 0xE);
     PrintTime(windowId, 0, 1, days, hours, minutes, seconds);
-    PrintTextOnWindow(windowId, 1, gText_Confirm2, 126, 1, 0, NULL);
+    AddTextPrinterParameterized(windowId, 1, gText_Confirm2, 126, 1, 0, NULL);
     schedule_bg_copy_tilemap_to_vram(0);
 }
 
@@ -496,7 +496,7 @@ static void VBlankCB(void)
 static void ShowMessage(const u8 *str)
 {
     sub_8197B1C(1, FALSE, 0x200, 0xF);
-    PrintTextOnWindow(1, 1, str, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(1, 1, str, 0, 1, 0, NULL);
     schedule_bg_copy_tilemap_to_vram(0);
 }
 
@@ -508,7 +508,7 @@ static void Task_ShowResetRtcPrompt(u8 taskId)
     {
     case 0:
         SetWindowBorderStyle(0, FALSE, 0x214, 0xE);
-        PrintTextOnWindow(0, 1, gText_PresentTime, 0, 1, TEXT_SPEED_FF, 0);
+        AddTextPrinterParameterized(0, 1, gText_PresentTime, 0, 1, TEXT_SPEED_FF, 0);
         PrintTime(
             0,
             0,
@@ -517,7 +517,7 @@ static void Task_ShowResetRtcPrompt(u8 taskId)
             gLocalTime.hours,
             gLocalTime.minutes,
             gLocalTime.seconds);
-        PrintTextOnWindow(0, 1, gText_PreviousTime, 0, 33, TEXT_SPEED_FF, 0);
+        AddTextPrinterParameterized(0, 1, gText_PreviousTime, 0, 33, TEXT_SPEED_FF, 0);
         PrintTime(
             0,
             0,
diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c
index b207d7e74..4c1da8620 100644
--- a/src/save_failed_screen.c
+++ b/src/save_failed_screen.c
@@ -173,7 +173,7 @@ static void SaveFailedScreenTextPrint(u8 *text, u8 var1, u8 var2)
     color[0] = 0;
     color[1] = 15;
     color[2] = 3;
-    AddTextPrinterParameterized2(gSaveFailedWindowIds[TEXT_WIN_ID], 1, var1 * 8, var2 * 8 + 1, 0, 0, color, 0, text);
+    AddTextPrinterParameterized4(gSaveFailedWindowIds[TEXT_WIN_ID], 1, var1 * 8, var2 * 8 + 1, 0, 0, color, 0, text);
 }
 
 void DoSaveFailedScreen(u8 saveType)
diff --git a/src/scrcmd.c b/src/scrcmd.c
index 31a4ed35a..acaf78576 100644
--- a/src/scrcmd.c
+++ b/src/scrcmd.c
@@ -1304,7 +1304,7 @@ bool8 ScrCmd_cmdDB(struct ScriptContext *ctx)
         msg = (const u8 *)ctx->data[0];
     sub_81973A4();
     NewMenuHelpers_DrawDialogueFrame(0, 1);
-    PrintTextOnWindow(0, 1, msg, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, msg, 0, 1, 0, 0);
     return FALSE;
 }
 
@@ -1521,7 +1521,7 @@ bool8 ScrCmd_braillemessage(struct ScriptContext *ctx)
     NewMenuHelpers_DrawStdWindowFrame(gUnknown_03000F30, 0);
     PutWindowTilemap(gUnknown_03000F30);
     FillWindowPixelBuffer(gUnknown_03000F30, 0x11);
-    PrintTextOnWindow(gUnknown_03000F30, 6, gStringVar4, xText, yText, 0xFF, 0x0);
+    AddTextPrinterParameterized(gUnknown_03000F30, 6, gStringVar4, xText, yText, 0xFF, 0x0);
     CopyWindowToVram(gUnknown_03000F30, 3);
     return FALSE;
 }
diff --git a/src/slot_machine.c b/src/slot_machine.c
index 6b6a46cf8..ed00f41c2 100644
--- a/src/slot_machine.c
+++ b/src/slot_machine.c
@@ -725,7 +725,7 @@ extern const u8 gText_YouveRunOutOfCoins[];
 bool8 sub_8101F44(struct Task *task)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, gText_YouDontHaveThreeCoins, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, gText_YouDontHaveThreeCoins, 0, 1, 0, 0);
     CopyWindowToVram(0, 3);
     sSlotMachine->state = 7;
     return FALSE;
@@ -966,7 +966,7 @@ bool8 sub_81022F0(struct Task *task)
 bool8 sub_8102318(struct Task *task)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, gText_QuitTheGame, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, gText_QuitTheGame, 0, 1, 0, 0);
     CopyWindowToVram(0, 3);
     sub_80323CC(0x15, 7, 0x214, 0x180, 0xE, 0xF);
     sSlotMachine->state = 22;
@@ -996,7 +996,7 @@ bool8 sub_8102344(struct Task *task)
 bool8 sub_810239C(struct Task *task)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, gText_YouveGot9999Coins, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, gText_YouveGot9999Coins, 0, 1, 0, 0);
     CopyWindowToVram(0, 3);
     sSlotMachine->state = 24;
     return FALSE;
@@ -1015,7 +1015,7 @@ bool8 sub_81023B8(struct Task *task)
 bool8 sub_81023E0_(struct Task *task)
 {
     NewMenuHelpers_DrawDialogueFrame(0, 0);
-    PrintTextOnWindow(0, 1, gText_YouveRunOutOfCoins, 0, 1, 0, 0);
+    AddTextPrinterParameterized(0, 1, gText_YouveRunOutOfCoins, 0, 1, 0, 0);
     CopyWindowToVram(0, 3);
     sSlotMachine->state = 26;
     return FALSE;
diff --git a/src/start_menu.c b/src/start_menu.c
index 4a58c146e..56dad89f7 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -377,7 +377,7 @@ static void ShowSafariBallsWindow(void)
     NewMenuHelpers_DrawStdWindowFrame(sSafariBallsWindowId, FALSE);
     ConvertIntToDecimalStringN(gStringVar1, gNumSafariBalls, STR_CONV_MODE_RIGHT_ALIGN, 2);
     StringExpandPlaceholders(gStringVar4, gText_SafariBallStock);
-    PrintTextOnWindow(sSafariBallsWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL);
+    AddTextPrinterParameterized(sSafariBallsWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL);
     CopyWindowToVram(sSafariBallsWindowId, 2);
 }
 
@@ -392,7 +392,7 @@ static void ShowPyramidFloorWindow(void)
     NewMenuHelpers_DrawStdWindowFrame(sBattlePyramidFloorWindowId, FALSE);
     StringCopy(gStringVar1, sPyramindFloorNames[gSaveBlock2Ptr->frontier.field_CB2]);
     StringExpandPlaceholders(gStringVar4, gText_BattlePyramidFloor);
-    PrintTextOnWindow(sBattlePyramidFloorWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL);
+    AddTextPrinterParameterized(sBattlePyramidFloorWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL);
     CopyWindowToVram(sBattlePyramidFloorWindowId, 2);
 }
 
@@ -422,7 +422,7 @@ static bool32 PrintStartMenuActions(s8 *pIndex, u32 count)
         }
         else {
             StringExpandPlaceholders(gStringVar4, sStartMenuItems[sCurrentStartMenuActions[index]].text);
-            PrintTextOnWindow(GetStartMenuWindowId(), 1, gStringVar4, 8, (index << 4) + 9, 0xFF, NULL);
+            AddTextPrinterParameterized(GetStartMenuWindowId(), 1, gStringVar4, 8, (index << 4) + 9, 0xFF, NULL);
         }
 
         index++;
@@ -1249,7 +1249,7 @@ static void sub_80A0550(u8 taskId)
         {
         case 0:
             FillWindowPixelBuffer(0, 17);
-            AddTextPrinterParameterized(0,
+            AddTextPrinterParameterized2(0,
                                         1,
                                         gText_SavingDontTurnOffPower,
                                         255,
@@ -1342,38 +1342,38 @@ static void ShowSaveInfoWindow(void)
     // Print region name
     yOffset = 1;
     sub_819A344(3, gStringVar4, TEXT_COLOR_GREEN);
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gStringVar4, 0, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gStringVar4, 0, yOffset, 0xFF, NULL);
 
     // Print player name
     yOffset = 0x11;
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gText_SavingPlayer, 0, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gText_SavingPlayer, 0, yOffset, 0xFF, NULL);
     sub_819A344(0, gStringVar4, color);
     xOffset = GetStringRightAlignXOffset(1, gStringVar4, 0x70);
     PrintPlayerNameOnWindow(sSaveInfoWindowId, gStringVar4, xOffset, yOffset);
 
     // Print badge count
     yOffset = 0x21;
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gText_SavingBadges, 0, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gText_SavingBadges, 0, yOffset, 0xFF, NULL);
     sub_819A344(4, gStringVar4, color);
     xOffset = GetStringRightAlignXOffset(1, gStringVar4, 0x70);
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
 
     if (FlagGet(FLAG_SYS_POKEDEX_GET) == TRUE)
     {
         // Print pokedex count
         yOffset = 0x31;
-        PrintTextOnWindow(sSaveInfoWindowId, 1, gText_SavingPokedex, 0, yOffset, 0xFF, NULL);
+        AddTextPrinterParameterized(sSaveInfoWindowId, 1, gText_SavingPokedex, 0, yOffset, 0xFF, NULL);
         sub_819A344(1, gStringVar4, color);
         xOffset = GetStringRightAlignXOffset(1, gStringVar4, 0x70);
-        PrintTextOnWindow(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
+        AddTextPrinterParameterized(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
     }
 
     // Print play time
     yOffset += 0x10;
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gText_SavingTime, 0, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gText_SavingTime, 0, yOffset, 0xFF, NULL);
     sub_819A344(2, gStringVar4, color);
     xOffset = GetStringRightAlignXOffset(1, gStringVar4, 0x70);
-    PrintTextOnWindow(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
+    AddTextPrinterParameterized(sSaveInfoWindowId, 1, gStringVar4, xOffset, yOffset, 0xFF, NULL);
 
     CopyWindowToVram(sSaveInfoWindowId, 2);
 }
diff --git a/src/starter_choose.c b/src/starter_choose.c
index 71784b016..179d9a05a 100644
--- a/src/starter_choose.c
+++ b/src/starter_choose.c
@@ -470,7 +470,7 @@ static void Task_StarterChoose1(u8 taskId)
 {
     CreateStarterPokemonLabel(gTasks[taskId].tStarterSelection);
     SetWindowBorderStyle(0, FALSE, 0x2A8, 0xD);
-    PrintTextOnWindow(0, 1, gText_BirchInTrouble, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(0, 1, gText_BirchInTrouble, 0, 1, 0, NULL);
     PutWindowTilemap(0);
     schedule_bg_copy_tilemap_to_vram(0);
     gTasks[taskId].func = Task_StarterChoose2;
@@ -524,7 +524,7 @@ static void Task_StarterChoose4(u8 taskId)
 {
     PlayCry1(GetStarterPokemon(gTasks[taskId].tStarterSelection), 0);
     FillWindowPixelBuffer(0, 0x11);
-    PrintTextOnWindow(0, 1, gText_ConfirmStarterChoice, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(0, 1, gText_ConfirmStarterChoice, 0, 1, 0, NULL);
     schedule_bg_copy_tilemap_to_vram(0);
     CreateYesNoMenu(&gUnknown_085B1DDC, 0x2A8, 0xD, 0);
     gTasks[taskId].func = Task_StarterChoose5;
@@ -582,10 +582,10 @@ static void CreateStarterPokemonLabel(u8 selection)
     FillWindowPixelBuffer(sStarterChooseWindowId, 0);
 
     width = GetStringCenterAlignXOffset(7, text, 0x68);
-    box_print(sStarterChooseWindowId, 7, width, 1, gUnknown_085B1E0C, 0, text);
+    AddTextPrinterParameterized3(sStarterChooseWindowId, 7, width, 1, gUnknown_085B1E0C, 0, text);
 
     width = GetStringCenterAlignXOffset(1, speciesName, 0x68);
-    box_print(sStarterChooseWindowId, 1, width, 0x11, gUnknown_085B1E0C, 0, speciesName);
+    AddTextPrinterParameterized3(sStarterChooseWindowId, 1, width, 0x11, gUnknown_085B1E0C, 0, speciesName);
 
     PutWindowTilemap(sStarterChooseWindowId);
     schedule_bg_copy_tilemap_to_vram(0);
diff --git a/src/text.c b/src/text.c
index ed70f767b..e5a9feed8 100644
--- a/src/text.c
+++ b/src/text.c
@@ -139,14 +139,14 @@ void SetFontsPointer(const struct FontInfo *fonts)
     gFonts = fonts;
 }
 
-void DeactivateAllTextPrinters (void)
+void DeactivateAllTextPrinters(void)
 {
     int printer;
     for (printer = 0; printer < NUM_TEXT_PRINTERS; ++printer)
         gTextPrinters[printer].sub_union.sub.active = 0;
 }
 
-u16 PrintTextOnWindow(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 TextSubPrinter *, u16))
 {
     struct TextSubPrinter subPrinter;
 
diff --git a/src/trader.c b/src/trader.c
index c4d70ac9a..f081d7e95 100644
--- a/src/trader.c
+++ b/src/trader.c
@@ -77,11 +77,11 @@ void CreateAvailableDecorationsMenu(u8 taskId)
     for (i = 0; i < 4; i++)
     {
         if (trader->decorIds[i] > NUM_DECORATIONS)
-            PrintTextOnWindow(data[3], 1, gText_FiveMarks, 8, 16 * i + 1, 255, NULL);
+            AddTextPrinterParameterized(data[3], 1, gText_FiveMarks, 8, 16 * i + 1, 255, NULL);
         else
-            PrintTextOnWindow(data[3], 1, gDecorations[trader->decorIds[i]].name, 8, 16 * i + 1, 255, NULL);
+            AddTextPrinterParameterized(data[3], 1, gDecorations[trader->decorIds[i]].name, 8, 16 * i + 1, 255, NULL);
     }
-    PrintTextOnWindow(data[3], 1, gText_Exit, 8, 16 * i + 1, 255, NULL);
+    AddTextPrinterParameterized(data[3], 1, gText_Exit, 8, 16 * i + 1, 255, NULL);
     InitMenuInUpperLeftCornerPlaySoundWhenAPressed(data[3], 5, 0);
     schedule_bg_copy_tilemap_to_vram(0);
 }
diff --git a/src/wallclock.c b/src/wallclock.c
index f3feab1d4..6bcfa1717 100644
--- a/src/wallclock.c
+++ b/src/wallclock.c
@@ -668,7 +668,7 @@ void CB2_StartWallClock(void)
 
     WallClockInit();
 
-    PrintTextOnWindow(1, 1, gText_Confirm3, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(1, 1, gText_Confirm3, 0, 1, 0, NULL);
     PutWindowTilemap(1);
     schedule_bg_copy_tilemap_to_vram(2);
 }
@@ -716,7 +716,7 @@ void CB2_ViewWallClock(void)
 
     WallClockInit();
 
-    PrintTextOnWindow(1, 1, gText_Cancel4, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(1, 1, gText_Cancel4, 0, 1, 0, NULL);
     PutWindowTilemap(1);
     schedule_bg_copy_tilemap_to_vram(2);
 }
@@ -783,7 +783,7 @@ static void Task_SetClock2(u8 taskId)
 static void Task_SetClock3(u8 taskId)
 {
     SetWindowBorderStyle(0, FALSE, 0x250, 0x0d);
-    PrintTextOnWindow(0, 1, gText_IsThisTheCorrectTime, 0, 1, 0, NULL);
+    AddTextPrinterParameterized(0, 1, gText_IsThisTheCorrectTime, 0, 1, 0, NULL);
     PutWindowTilemap(0);
     schedule_bg_copy_tilemap_to_vram(0);
     CreateYesNoMenu(&gUnknown_085B21F4, 0x250, 0x0d, 1);