Decompile the rest of text.c

1 files changed, 601 insertions, 2 deletions

diff --git a/src/text.c b/src/text.c
index 01f8ab2e..10b504f8 100644
--- a/src/text.c
+++ b/src/text.c
@@ -4,6 +4,8 @@
 #include "functions.h"
 #include "asm.h"
 #include "enemy.h"
+#include "message.h"
+#include "fileselect.h"
 
 extern u16 gUnk_081092D4;
 extern u8 gUnk_081094CE;
@@ -17,6 +19,8 @@ typedef struct {
 
 extern VStruct gUnk_0810942E[];
 extern u32 gUnk_0810926C[];
+extern u32* Translations[];
+extern u32 gUnk_08109244;
 
 typedef struct {
     u8 unk0;
@@ -24,6 +28,599 @@ typedef struct {
 } UStruct;
 
 void sub_0805F820(WStruct* r0, u32* r1);
+bool32 sub_0805EF40(Token* tok, const u8*);
+void sub_0805F440(Token*, u8*);
+u32 sub_0805F6A4(Token*, WStruct*);
+u32 GetCharacter(Token* tok);
+u32 GetFontStrWith(Token*, u32);
+int sub_0805F67C(short*, int, int);
+void sub_0805F918(u32, u32, void*);
+bool32 sub_0805F5CC(Font*, Token*, WStruct*);
+void sub_0805EEB4(Token*, u32);
+u32 sub_0805EF8C(Token*);
+u32 sub_0805EFB4(Token*);
+u32 sub_0805F9A0(u32);
+
+typedef struct {
+    u16 unk0;
+    s8 unk2;
+    s8 unk3;
+    u8 filler[0x4];
+    u16 unk8[4];
+    u16 unk10[4];
+} struct_gUnk_02034330;
+
+extern struct_gUnk_02034330 gUnk_02034330;
+extern WStruct gUnk_02036540[4];
+extern u32* gUnk_08109248[];
+extern u8* gUnk_08109230[];
+extern u32* gTranslations[];
+extern u32 gUnk_08109244;
+
+void sub_0805EEB4(Token* token, u32 textIndex) {
+    u32 langIndex;
+    u32* puVar2;
+    u8* puVar5;
+    int iVar3;
+    u32 uVar4;
+    u32 uVar6;
+    u32 uVar7;
+
+    token->textIndex = (u16)textIndex;
+    langIndex = gSaveHeader->language;
+    if (((1 < langIndex) && (textIndex >> 8 == 1)) && (textIndex < 0x119)) {
+        langIndex = 3;
+    }
+    puVar2 = gTranslations[langIndex];
+    iVar3 = puVar2[(u8)(textIndex >> 8)];
+    puVar2 = (u32*)((int)puVar2 + iVar3);
+    iVar3 = puVar2[(u8)textIndex];
+    uVar6 = *(gTranslations[langIndex]) >> 2;
+    uVar7 = *puVar2 >> 2;
+    uVar4 = 0;
+    if (((token->textIndex >> 8) >= uVar6) || ((u8)token->textIndex >= uVar7)) {
+        uVar4 = 1;
+    } else {
+        if (*(char*)((int)puVar2 + iVar3) == 0) {
+            uVar4 = 2;
+        }
+    }
+    switch (uVar4) {
+        case 1:
+        case 2:
+            puVar2 = &gUnk_08109244;
+            iVar3 = 0;
+            break;
+    }
+    puVar2 = (u32*)((int)puVar2 + iVar3);
+    sub_0805EF40(token, (u8*)puVar2);
+}
+
+bool32 sub_0805EF40(Token* token, const u8* param_2) {
+    if (token->unk00 != 0) {
+        if (6 < token->unk01) {
+            return 0;
+        }
+        token->unk01++;
+    }
+    token->buf[token->unk01] = param_2;
+    token->unk00 = 1;
+    return 1;
+}
+
+u32 sub_0805EF8C(Token* token) {
+    if (token->unk00 == 0) {
+        return 0;
+    }
+    return (token->buf[token->unk01]++)[0];
+}
+
+u32 sub_0805EFB4(Token* token) {
+    u32 rv = token->unk01;
+
+    if (token->unk01 != 0) {
+        token->unk01--;
+    } else {
+        token->unk00 = 0;
+    }
+    return rv;
+}
+
+u32 GetCharacter(Token* token) {
+    u32 uVar3;
+    u32 code;
+    u32 uVar6;
+    u8** ppuVar7;
+    int iVar8;
+
+    do {
+        code = sub_0805EF8C(token);
+        token->code = (u8)code;
+        iVar8 = 0;
+        switch (code) {
+            case 0:
+                iVar8 = sub_0805EFB4(token);
+                code = 0;
+                break;
+            case 1:
+                uVar6 = sub_0805EF8C(token);
+                token->param = (u16)uVar6;
+                code = 6;
+                if (uVar6 < 0xb) {
+                    code = 5;
+                }
+                break;
+            case 2:
+                uVar3 = sub_0805EF8C(token);
+                token->param = uVar3;
+                code = 7;
+                break;
+            case 3:
+                uVar6 = sub_0805EF8C(token) << 8;
+                uVar6 += sub_0805EF8C(token);
+                token->param = uVar6;
+                code = 8;
+                break;
+            case 4:
+                uVar6 = sub_0805EF8C(token);
+                switch (uVar6) {
+                    case 0:
+                    case 1:
+                    case 2:
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                    case 8:
+                    case 9:
+                    case 10:
+                    case 0xb:
+                    case 0xc:
+                    case 0xd:
+                    case 0xe:
+                    case 0xf:
+                        code = 9;
+                        break;
+                    case 0x10:
+                        uVar6 = sub_0805EF8C(token);
+                        code = 10;
+                        break;
+                    case 0x11:
+                        code = 2;
+                        break;
+                    case 0x12:
+                        code = 3;
+                        break;
+                    case 0x13:
+                        code = 4;
+                        break;
+                    case 0x14:
+                    case 0x15:
+                        code = 0xb;
+                        // This is a comparison to 0 but couldn't make it do the bit trick
+                        uVar6 = (-(uVar6 ^ 0x14) | (uVar6 ^ 0x14)) >> 0x1f;
+                }
+                token->param = (u16)uVar6;
+                break;
+            case 5:
+                uVar6 = sub_0805EF8C(token);
+                if (uVar6 == 0xff) {
+                    uVar6 = 0;
+                } else {
+                    uVar6 <<= 8;
+                    uVar6 += sub_0805EF8C(token);
+                }
+                token->_6 = uVar6;
+                code = 0xc;
+                break;
+            case 6:
+                uVar6 = sub_0805EF8C(token);
+                switch (uVar6) {
+                    case 0 ... 4:
+                        ppuVar7 = (u8**)token->_c;
+                        if (ppuVar7 == NULL) {
+                            ppuVar7 = gUnk_08109230;
+                        }
+                        sub_0805EF40(token, ppuVar7[uVar6]);
+                        break;
+                    case 5:
+                        uVar6 = sub_0805EF8C(token) << 8;
+                        uVar6 += sub_0805EF8C(token);
+                        sub_0805EEB4(token, uVar6);
+                        break;
+                    default:
+                        break;
+                }
+                iVar8 = 1;
+                break;
+            case 7:
+                uVar6 = sub_0805EF8C(token) << 8;
+                uVar6 += sub_0805EF8C(token);
+                token->unk00 = 0;
+                token->unk01 = 0;
+                sub_0805EEB4(token, uVar6);
+                iVar8 = 1;
+                break;
+            case 8:
+                uVar3 = sub_0805EF8C(token);
+                token->param = uVar3;
+                code = 0xd;
+                break;
+            case 9:
+                uVar3 = sub_0805EF8C(token);
+                token->param = uVar3;
+                code = 0xe;
+                break;
+            case 10:
+                code = 1;
+                break;
+            case 0xb:
+                code = sub_0805EF8C(token);
+                code |= 0x400;
+                break;
+            case 0xc:
+                code = sub_0805EF8C(token);
+                code |= 0x700;
+                break;
+            case 0xd:
+                code = sub_0805EF8C(token);
+                code |= 0x500;
+                break;
+            case 0xe:
+                code = sub_0805EF8C(token);
+                code |= 0x600;
+                break;
+            case 0xf:
+                code = sub_0805EF8C(token);
+                code |= 0x300;
+                break;
+            default:
+                code += 0x100;
+                break;
+        }
+    } while (iVar8);
+
+    if (code >> 8 != 0) {
+        switch (token->unk05) {
+            case 0:
+                break;
+            case 1:
+                code = sub_0805F9A0(code);
+                break;
+        }
+        token->extended = (u16)code;
+    }
+    return code;
+}
+
+u32* sub_0805F25C(u32 param_1) {
+    u32 uVar1;
+
+    uVar1 = param_1 >> 8 & 0xf;
+    param_1 = param_1 & 0xff;
+    switch (uVar1) {
+        case 0:
+        case 1:
+            if (0x7f < param_1 && gSaveHeader->language != 0) {
+                param_1 = param_1 - 0x80;
+                uVar1 = 2;
+            }
+            break;
+        case 2:
+        case 3:
+        case 4:
+            break;
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+            param_1 = param_1 << 1;
+            break;
+    }
+    return gUnk_08109248[uVar1] + param_1 * 0x10;
+}
+
+WStruct* sub_0805F2C8(void) {
+    u32 uVar2;
+
+    for (uVar2 = 0; uVar2 < ARRAY_COUNT(gUnk_02036540); uVar2++) {
+        if ((gUnk_02036540[uVar2].unk00) == 0) {
+            MemClear(&gUnk_02036540[uVar2], sizeof(WStruct));
+            gUnk_02036540[uVar2].unk00 = 1;
+            return &gUnk_02036540[uVar2];
+        }
+    }
+
+    return NULL;
+}
+
+void sub_0805F300(WStruct* param_1) {
+    u32 uVar2;
+
+    for (uVar2 = 0; uVar2 < ARRAY_COUNT(gUnk_02036540); uVar2++) {
+        if (&gUnk_02036540[uVar2] == param_1) {
+            MemClear(&gUnk_02036540[uVar2], sizeof(WStruct));
+            return;
+        }
+    }
+}
+
+u32 GetFontStrWith(Token* param_1, u32 param_2) {
+    u32 character;
+    u32* puVar2;
+    u32 uVar3;
+    u32 uVar4;
+    u16 uVar5;
+    u32 rv;
+    u32 r9;
+    Token token;
+    int local_28;
+    int local_24;
+
+    MemCopy(param_1, &token, sizeof(Token));
+    local_24 = 0;
+    local_28 = 0;
+    rv = 0;
+    uVar5 = 0;
+    do {
+        uVar4 = 0;
+        r9 = 1;
+        while (r9) {
+            character = GetCharacter(&token);
+            switch (character) {
+                case 0xc:
+                    uVar4 += 8;
+                    break;
+                case 0xb:
+                    uVar5 = token.param;
+                    break;
+                case 0:
+                case 1:
+                    r9 = 0;
+                    break;
+                case 2 ... 10:
+                case 0xd:
+                case 0xe:
+                    break;
+                default:
+                    if (uVar5 == 0) {
+                        puVar2 = (u32*)sub_0805F25C(character);
+                        if (4 < character >> 8) {
+                            uVar3 = sub_0805F7A0(puVar2[0x10]);
+                            uVar4 += (uVar3 >> 8);
+                        }
+                        uVar3 = sub_0805F7A0(*puVar2);
+                        uVar4 += (uVar3 >> 8);
+                    } else if (character >> 8 >= 5) {
+                        uVar4 += 0x10;
+                    } else {
+                        uVar4 += 8;
+                    }
+                    if (token.unk05 == 1 && uVar4 > 1) {
+                        uVar4--;
+                    }
+            }
+        }
+        if (uVar4 > rv) {
+            rv = uVar4;
+        }
+        if (uVar4 != 0) {
+            local_28++;
+        } else {
+            local_24++;
+        }
+    } while ((param_2 != 0) && (character != 0));
+
+    if (param_2 != 0) {
+        return local_24 << 0x18 | local_28 << 0x10 | rv;
+    }
+    return rv;
+}
+
+void sub_0805F440(Token* param_1, u8* param_2) {
+    MemClear(param_1, sizeof(Token));
+    if ((u32)param_2 >= 0x10000) {
+        sub_0805EF40(param_1, param_2);
+    } else {
+        sub_0805EEB4(param_1, (u32)param_2);
+    }
+}
+
+u32 sub_0805F46C(u32 param_1, Font* param_2) {
+    u32 uVar1;
+    WStruct* pWVar4;
+    u32 uVar5;
+    u16* puVar6;
+    u32 uVar7;
+    u32 uVar8;
+    u16* puVar9;
+    u32 iVar10;
+    Token token;
+    Font font;
+    u32 fontStr;
+    u32 temp2;
+    u32 temp3;
+
+    pWVar4 = sub_0805F2C8();
+    if (pWVar4 != NULL) {
+        MemCopy(param_2, &font, sizeof(Font));
+        sub_0805F440(&token, (u8*)param_1);
+        token.unk05 = font.stylized & 3;
+        pWVar4->unk04 = font.stylized;
+        pWVar4->unk4 = font.width;
+        pWVar4->unk8 = font.buffer_loc;
+        pWVar4->charColor = font._15;
+        pWVar4->bgColor = font.fill_type;
+        if (font.draw_border) {
+            sub_0805F918(font.border_type, font.fill_type, font.gfx_dest);
+            font.gfx_dest = (void*)((int)font.gfx_dest + 0xe0);
+            fontStr = GetFontStrWith(&token, 1);
+            iVar10 = (fontStr >> 0x18) * (u32)font._16 + ((u8)((int)fontStr >> 0x10) << 1);
+            uVar8 = (u16)fontStr;
+            temp3 = uVar8;
+            if (font.width < (s32)temp3) {
+                temp3 = font.width;
+            }
+            uVar8 = (temp3 + 7);
+            temp2 = ~7;
+            uVar8 = font.sm_border ? uVar8 & temp2 : font.width;
+
+            puVar9 = font.dest;
+            font.dest += 0x20;
+
+            if (font.right_align) {
+                uVar8 = (uVar8 + 0xf) & ~0xf;
+                puVar9 -= (uVar8 >> 4) + 1;
+            } else {
+                font.dest += 1;
+            }
+            uVar8 = uVar8 >> 3;
+            param_1 = font.gfx_src;
+            DispMessageFrame(puVar9, uVar8, iVar10, param_1);
+            puVar9 = puVar9 + 1;
+            font.gfx_src = font.gfx_src + 7;
+            param_1 = font.gfx_src - 1;
+            while (iVar10-- > 0) {
+                puVar9 += 0x20;
+                puVar6 = puVar9;
+                for (uVar5 = uVar8; (int)uVar5-- > 0;) {
+                    *puVar6++ = param_1;
+                }
+            }
+        }
+        MemClear(&gUnk_02034330, sizeof(gUnk_02034330));
+        while ((s16)sub_0805F5CC(&font, &token, pWVar4) != 0) {}
+        sub_0805F300(pWVar4);
+    }
+    return 0;
+}
+
+bool32 sub_0805F5CC(Font* param_1, Token* param_2, WStruct* param_3) {
+    u16 uVar2;
+    u32 uVar3;
+    int iVar4;
+    u16* puVar5;
+    u32 fontStr;
+
+    uVar3 = sub_0805F8F8(param_1->fill_type);
+    MemFill32(uVar3, param_1->buffer_loc, ((param_1->width + 7) & 0x1f8) << 3);
+    fontStr = GetFontStrWith(param_2, 0);
+    param_3->unk6 = param_1->right_align ? ((8 - ((fontStr + 1) >> 1)) & 7) : 0;
+
+    puVar5 = (u16*)sub_0805F6A4(param_2, param_3);
+    if (puVar5) {
+        iVar4 = (int)(param_3->unk6 + 7) / 8;
+        puVar5 = param_1->dest;
+        if (param_1->right_align) {
+            puVar5 -= (iVar4 + 1U) >> 1;
+        }
+        param_1->gfx_src = sub_0805F67C(puVar5, param_1->gfx_src, iVar4);
+        param_1->dest += 0x40;
+        iVar4 *= 0x40;
+        MemCopy(param_1->buffer_loc, param_1->gfx_dest, iVar4);
+        param_1->gfx_dest = (void*)((int)param_1->gfx_dest + iVar4);
+    } else {
+        if (param_2->code == 10) {
+            param_1->dest += param_1->_16 * 0x20;
+        }
+    }
+    return param_2->code > 0;
+}
+
+int sub_0805F67C(short* param_1, int param_2, int param_3) {
+    for (param_3--; param_3 != -1; param_3--) {
+        param_1[0] = param_2++;
+        param_1[0x20] = param_2++;
+        param_1++;
+    }
+    return param_2;
+}
+
+u32 sub_0805F6A4(Token* param_1, WStruct* param_2) {
+    u32 uVar1;
+    u32 uVar3;
+    int iVar4;
+    u32 r7;
+
+    iVar4 = 0;
+    r7 = 1;
+    do {
+        uVar1 = GetCharacter(param_1);
+        r7 = 1;
+        switch (uVar1) {
+            case 7:
+                if (param_1->param < 0xe) {
+                    param_2->charColor = param_1->param;
+                }
+                break;
+            case 0:
+            case 1:
+                r7 = 0;
+                break;
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 8:
+            case 9:
+            case 10:
+            case 0xd:
+            case 0xe:
+                break;
+
+            case 0xc:
+                uVar3 = gUnk_02034330.unk2;
+                if (uVar3 < 4) {
+                    gUnk_02034330.unk2 = uVar3 + 1;
+                    gUnk_02034330.unk10[uVar3] = param_1->_6;
+                    gUnk_02034330.unk8[uVar3] = param_2->unk6;
+                }
+                param_2->unk6 += 8;
+                iVar4 += 8;
+                break;
+            case 0xb:
+                param_2->unk1 = param_1->param;
+                break;
+            default:
+                iVar4 += sub_0805F7DC(uVar1, param_2);
+                if ((param_1->unk05 == 1) && (1 < param_2->unk6)) {
+                    iVar4--;
+                    param_2->unk6 = param_2->unk6 - 1;
+                }
+                break;
+        }
+    } while (r7);
+
+    return iVar4;
+}
+
+u32 sub_0805F76C(u8* param_1, WStruct* param_2) {
+    u32 uVar1;
+    Token local_38;
+
+    sub_0805F440(&local_38, param_1);
+    local_38.unk05 = param_2->unk04 & 3;
+    uVar1 = sub_0805F6A4(&local_38, param_2);
+    return uVar1;
+}
+
+u32 sub_0805F7A0(u32 param_1) {
+    u32 uVar1;
+    u32 uVar2;
+    u32 uVar3;
+
+    uVar1 = 0xf;
+    for (uVar2 = 0; uVar2 < 8; uVar2++) {
+        if (uVar1 != (param_1 & uVar1))
+            break;
+        uVar1 <<= 4;
+    }
+    for (uVar3 = uVar2; (uVar2 < 8 && (uVar1 != (param_1 & uVar1))); uVar1 <<= 4, uVar2++) {}
+    uVar2 -= uVar3;
+    return (uVar2 << 8) | uVar3;
+}
 
 u32 sub_0805F7DC(u32 r0, WStruct* r1) {
     u32 temp;
@@ -59,6 +656,7 @@ void sub_0805F820(WStruct* r0, u32* r1) {
     u8* temp;
     void* temp2;
     VStruct* temp3;
+    u32 temp4;
 
     if (r0->unk4 - r0->unk6 > 0) {
         sub_08002724(r1, &gUnk_02036A58);
@@ -81,11 +679,12 @@ void sub_0805F820(WStruct* r0, u32* r1) {
 
         puVar8 = &gUnk_02036A58 + uVar6;
         temp2 = r0->unk8;
-        temp = gUnk_0810942E[r0->unk3].filler0[r0->unk2 * 2];
+        temp = gUnk_0810942E[r0->bgColor].filler0[r0->charColor * 2];
         uVar7 = r0->unk6;
         r0->unk6 += uVar3;
 
-        if (r0->unk0 / 16 != 1) {
+        temp4 = r0->unk04;
+        if (temp4 != 1) {
             while (uVar3-- > 0) {
                 sub_080026C4(puVar8, temp2, temp, uVar7);
                 puVar8++;