#include "character_editor.h"

#include "art.h"
#include "color.h"
#include "core.h"
#include "critter.h"
#include "cycle.h"
#include "db.h"
#include "dbox.h"
#include "debug.h"
#include "draw.h"
#include "game.h"
#include "game_mouse.h"
#include "game_palette.h"
#include "game_sound.h"
#include "geometry.h"
#include "interface.h"
#include "item.h"
#include "map.h"
#include "memory.h"
#include "message.h"
#include "object.h"
#include "palette.h"
#include "perk.h"
#include "platform_compat.h"
#include "proto.h"
#include "scripts.h"
#include "sfall_config.h"
#include "skill.h"
#include "stat.h"
#include "text_font.h"
#include "trait.h"
#include "window_manager.h"
#include "word_wrap.h"
#include "world_map.h"

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

#include <vector>

#define RENDER_ALL_STATS 7

#define EDITOR_WINDOW_WIDTH 640
#define EDITOR_WINDOW_HEIGHT 480

#define NAME_BUTTON_X 9
#define NAME_BUTTON_Y 0

#define TAG_SKILLS_BUTTON_X 347
#define TAG_SKILLS_BUTTON_Y 26
#define TAG_SKILLS_BUTTON_CODE 536

#define PRINT_BTN_X 363
#define PRINT_BTN_Y 454

#define DONE_BTN_X 475
#define DONE_BTN_Y 454

#define CANCEL_BTN_X 571
#define CANCEL_BTN_Y 454

#define NAME_BTN_CODE 517
#define AGE_BTN_CODE 519
#define SEX_BTN_CODE 520

#define OPTIONAL_TRAITS_LEFT_BTN_X 23
#define OPTIONAL_TRAITS_RIGHT_BTN_X 298
#define OPTIONAL_TRAITS_BTN_Y 352

#define OPTIONAL_TRAITS_BTN_CODE 555

#define OPTIONAL_TRAITS_BTN_SPACE 2

#define SPECIAL_STATS_BTN_X 149

#define PERK_WINDOW_X 33
#define PERK_WINDOW_Y 91
#define PERK_WINDOW_WIDTH 573
#define PERK_WINDOW_HEIGHT 230

#define PERK_WINDOW_LIST_X 45
#define PERK_WINDOW_LIST_Y 43
#define PERK_WINDOW_LIST_WIDTH 192
#define PERK_WINDOW_LIST_HEIGHT 129

#define ANIMATE 0x01
#define RED_NUMBERS 0x02
#define BIG_NUM_WIDTH 14
#define BIG_NUM_HEIGHT 24
#define BIG_NUM_ANIMATION_DELAY 123

// TODO: Should be MAX(PERK_COUNT, TRAIT_COUNT).
#define DIALOG_PICKER_NUM_OPTIONS PERK_COUNT
#define TOWN_REPUTATION_COUNT 19
#define ADDICTION_REPUTATION_COUNT 8

typedef enum EditorFolder {
    EDITOR_FOLDER_PERKS,
    EDITOR_FOLDER_KARMA,
    EDITOR_FOLDER_KILLS,
} EditorFolder;

enum {
    EDITOR_DERIVED_STAT_ARMOR_CLASS,
    EDITOR_DERIVED_STAT_ACTION_POINTS,
    EDITOR_DERIVED_STAT_CARRY_WEIGHT,
    EDITOR_DERIVED_STAT_MELEE_DAMAGE,
    EDITOR_DERIVED_STAT_DAMAGE_RESISTANCE,
    EDITOR_DERIVED_STAT_POISON_RESISTANCE,
    EDITOR_DERIVED_STAT_RADIATION_RESISTANCE,
    EDITOR_DERIVED_STAT_SEQUENCE,
    EDITOR_DERIVED_STAT_HEALING_RATE,
    EDITOR_DERIVED_STAT_CRITICAL_CHANCE,
    EDITOR_DERIVED_STAT_COUNT,
};

enum {
    EDITOR_FIRST_PRIMARY_STAT,
    EDITOR_HIT_POINTS = 43,
    EDITOR_POISONED,
    EDITOR_RADIATED,
    EDITOR_EYE_DAMAGE,
    EDITOR_CRIPPLED_RIGHT_ARM,
    EDITOR_CRIPPLED_LEFT_ARM,
    EDITOR_CRIPPLED_RIGHT_LEG,
    EDITOR_CRIPPLED_LEFT_LEG,
    EDITOR_FIRST_DERIVED_STAT,
    EDITOR_FIRST_SKILL = EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_COUNT,
    EDITOR_TAG_SKILL = EDITOR_FIRST_SKILL + SKILL_COUNT,
    EDITOR_SKILLS,
    EDITOR_OPTIONAL_TRAITS,
    EDITOR_FIRST_TRAIT,
    EDITOR_BUTTONS_COUNT = EDITOR_FIRST_TRAIT + TRAIT_COUNT,
};

enum {
    EDITOR_GRAPHIC_BIG_NUMBERS,
    EDITOR_GRAPHIC_AGE_MASK,
    EDITOR_GRAPHIC_AGE_OFF,
    EDITOR_GRAPHIC_DOWN_ARROW_OFF,
    EDITOR_GRAPHIC_DOWN_ARROW_ON,
    EDITOR_GRAPHIC_NAME_MASK,
    EDITOR_GRAPHIC_NAME_ON,
    EDITOR_GRAPHIC_NAME_OFF,
    EDITOR_GRAPHIC_FOLDER_MASK, // mask for all three folders
    EDITOR_GRAPHIC_SEX_MASK,
    EDITOR_GRAPHIC_SEX_OFF,
    EDITOR_GRAPHIC_SEX_ON,
    EDITOR_GRAPHIC_SLIDER, // image containing small plus/minus buttons appeared near selected skill
    EDITOR_GRAPHIC_SLIDER_MINUS_OFF,
    EDITOR_GRAPHIC_SLIDER_MINUS_ON,
    EDITOR_GRAPHIC_SLIDER_PLUS_OFF,
    EDITOR_GRAPHIC_SLIDER_PLUS_ON,
    EDITOR_GRAPHIC_SLIDER_TRANS_MINUS_OFF,
    EDITOR_GRAPHIC_SLIDER_TRANS_MINUS_ON,
    EDITOR_GRAPHIC_SLIDER_TRANS_PLUS_OFF,
    EDITOR_GRAPHIC_SLIDER_TRANS_PLUS_ON,
    EDITOR_GRAPHIC_UP_ARROW_OFF,
    EDITOR_GRAPHIC_UP_ARROW_ON,
    EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP,
    EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN,
    EDITOR_GRAPHIC_AGE_ON,
    EDITOR_GRAPHIC_AGE_BOX, // image containing right and left buttons with age stepper in the middle
    EDITOR_GRAPHIC_ATTRIBOX, // ??? black image with two little arrows (up and down) in the right-top corner
    EDITOR_GRAPHIC_ATTRIBWN, // ??? not sure where and when it's used
    EDITOR_GRAPHIC_CHARWIN, // ??? looks like metal plate
    EDITOR_GRAPHIC_DONE_BOX, // metal plate holding DONE button
    EDITOR_GRAPHIC_FEMALE_OFF,
    EDITOR_GRAPHIC_FEMALE_ON,
    EDITOR_GRAPHIC_MALE_OFF,
    EDITOR_GRAPHIC_MALE_ON,
    EDITOR_GRAPHIC_NAME_BOX, // placeholder for name
    EDITOR_GRAPHIC_LEFT_ARROW_UP,
    EDITOR_GRAPHIC_LEFT_ARROW_DOWN,
    EDITOR_GRAPHIC_RIGHT_ARROW_UP,
    EDITOR_GRAPHIC_RIGHT_ARROW_DOWN,
    EDITOR_GRAPHIC_BARARRWS, // ??? two arrows up/down with some strange knob at the top, probably for scrollbar
    EDITOR_GRAPHIC_OPTIONS_BASE, // options metal plate
    EDITOR_GRAPHIC_OPTIONS_BUTTON_OFF,
    EDITOR_GRAPHIC_OPTIONS_BUTTON_ON,
    EDITOR_GRAPHIC_KARMA_FOLDER_SELECTED, // all three folders with middle folder selected (karma)
    EDITOR_GRAPHIC_KILLS_FOLDER_SELECTED, // all theee folders with right folder selected (kills)
    EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED, // all three folders with left folder selected (perks)
    EDITOR_GRAPHIC_KARMAFDR_PLACEOLDER, // ??? placeholder for traits folder image <- this is comment from intrface.lst
    EDITOR_GRAPHIC_TAG_SKILL_BUTTON_OFF,
    EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON,
    EDITOR_GRAPHIC_COUNT,
};

typedef struct KarmaEntry {
    int gvar;
    int art_num;
    int name;
    int description;
} KarmaEntry;

typedef struct GenericReputationEntry {
    int threshold;
    int name;
} GenericReputationEntry;

typedef struct TownReputationEntry {
    int gvar;
    int city;
} TownReputationEntry;

typedef struct PerkDialogOption {
    // Depending on the current mode this value is the id of either
    // perk, trait (handling Mutate perk), or skill (handling Tag perk).
    int value;
    char* name;
} PerkDialogOption;

// TODO: Field order is probably wrong.
typedef struct KillInfo {
    const char* name;
    int killTypeId;
    int kills;
} KillInfo;

static int characterEditorWindowInit();
static void characterEditorWindowFree();
static int _get_input_str(int win, int cancelKeyCode, char* text, int maxLength, int x, int y, int textColor, int backgroundColor, int flags);
static void characterEditorDrawFolders();
static void characterEditorDrawPerksFolder();
static int characterEditorKillsCompare(const void* a1, const void* a2);
static int characterEditorDrawKillsFolder();
static void characterEditorDrawBigNumber(int x, int y, int flags, int value, int previousValue, int windowHandle);
static void characterEditorDrawPcStats();
static void characterEditorDrawPrimaryStat(int stat, bool animate, int previousValue);
static void characterEditorDrawGender();
static void characterEditorDrawAge();
static void characterEditorDrawName();
static void characterEditorDrawDerivedStats();
static void characterEditorDrawSkills(int a1);
static void characterEditorDrawCard();
static int characterEditorEditName();
static void _PrintName(unsigned char* buf, int pitch);
static int characterEditorEditAge();
static void characterEditorEditGender();
static void characterEditorAdjustPrimaryStat(int eventCode);
static int characterEditorShowOptions();
static bool characterFileExists(const char* fname);
static int characterPrintToFile(const char* fileName);
static char* _AddSpaces(char* string, int length);
static char* _AddDots(char* string, int length);
static void characterEditorResetScreen();
static void characterEditorRegisterInfoAreas();
static void characterEditorSavePlayer();
static void characterEditorRestorePlayer();
static char* _itostndn(int value, char* dest);
static int characterEditorDrawCardWithOptions(int graphicId, const char* name, const char* attributes, char* description);
static void characterEditorHandleFolderButtonPressed();
static void characterEditorHandleInfoButtonPressed(int eventCode);
static void characterEditorHandleAdjustSkillButtonPressed(int a1);
static void characterEditorToggleTaggedSkill(int skill);
static void characterEditorDrawOptionalTraits();
static void characterEditorToggleOptionalTrait(int trait);
static void characterEditorDrawKarmaFolder();
static int characterEditorUpdateLevel();
static void perkDialogRefreshPerks();
static int perkDialogShow();
static int perkDialogHandleInput(int count, void (*refreshProc)());
static int perkDialogDrawPerks();
static void perkDialogRefreshTraits();
static bool perkDialogHandleMutatePerk();
static void perkDialogRefreshSkills();
static bool perkDialogHandleTagPerk();
static void perkDialogDrawSkills();
static int perkDialogDrawTraits(int a1);
static int perkDialogOptionCompare(const void* a1, const void* a2);
static int perkDialogDrawCard(int frmId, const char* name, const char* rank, char* description);
static void _pop_perks();
static int _is_supper_bonus();
static int characterEditorFolderViewInit();
static void characterEditorFolderViewScroll(int direction);
static void characterEditorFolderViewClear();
static int characterEditorFolderViewDrawHeading(const char* string);
static bool characterEditorFolderViewDrawString(const char* string);
static bool characterEditorFolderViewDrawKillsEntry(const char* name, int kills);
static int karmaInit();
static void karmaFree();
static int karmaEntryCompare(const void* a1, const void* a2);
static int genericReputationInit();
static void genericReputationFree();
static int genericReputationCompare(const void* a1, const void* a2);

static void customKarmaFolderInit();
static void customKarmaFolderFree();
static int customKarmaFolderGetFrmId();

// 0x431C40
static int gCharacterEditorFrmIds[EDITOR_GRAPHIC_COUNT] = {
    170,
    175,
    176,
    181,
    182,
    183,
    184,
    185,
    186,
    187,
    188,
    189,
    190,
    191,
    192,
    193,
    194,
    195,
    196,
    197,
    198,
    199,
    200,
    8,
    9,
    204,
    205,
    206,
    207,
    208,
    209,
    210,
    211,
    212,
    213,
    214,
    122,
    123,
    124,
    125,
    219,
    220,
    221,
    222,
    178,
    179,
    180,
    38,
    215,
    216,
};

// flags to preload fid
//
// 0x431D08
static const unsigned char gCharacterEditorFrmShouldCopy[EDITOR_GRAPHIC_COUNT] = {
    0,
    0,
    1,
    0,
    0,
    0,
    1,
    1,
    0,
    0,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    0,
    0,
};

// graphic ids for derived stats panel
// NOTE: the type originally short
//
// 0x431D3A
static const int gCharacterEditorDerivedStatFrmIds[EDITOR_DERIVED_STAT_COUNT] = {
    18,
    19,
    20,
    21,
    22,
    23,
    83,
    24,
    25,
    26,
};

// y offsets for stats +/- buttons
//
// 0x431D50
static const int gCharacterEditorPrimaryStatY[7] = {
    37,
    70,
    103,
    136,
    169,
    202,
    235,
};

// stat ids for derived stats panel
// NOTE: the type is originally short
//
// 0x431D6
static const int gCharacterEditorDerivedStatsMap[EDITOR_DERIVED_STAT_COUNT] = {
    STAT_ARMOR_CLASS,
    STAT_MAXIMUM_ACTION_POINTS,
    STAT_CARRY_WEIGHT,
    STAT_MELEE_DAMAGE,
    STAT_DAMAGE_RESISTANCE,
    STAT_POISON_RESISTANCE,
    STAT_RADIATION_RESISTANCE,
    STAT_SEQUENCE,
    STAT_HEALING_RATE,
    STAT_CRITICAL_CHANCE,
};

// 0x431D93
static char byte_431D93[64];

// 0x431DD4
static const int dword_431DD4[7] = {
    1000000,
    100000,
    10000,
    1000,
    100,
    10,
    1,
};

// 0x5016E4
static char byte_5016E4[] = "------";

// 0x50170B
static const double dbl_50170B = 14.4;

// 0x501713
static const double dbl_501713 = 19.2;

// 0x5018F0
static const double dbl_5018F0 = 19.2;

// 0x5019BE
static const double dbl_5019BE = 14.4;

// 0x518528
static bool gCharacterEditorIsoWasEnabled = false;

// 0x51852C
static int gCharacterEditorCurrentSkill = 0;

// 0x518534
static int gCharacterEditorSkillValueAdjustmentSliderY = 27;

// 0x518538
int gCharacterEditorRemainingCharacterPoints = 0;

// 0x51853C
static KarmaEntry* gKarmaEntries = NULL;

// 0x518540
static int gKarmaEntriesLength = 0;

// 0x518544
static GenericReputationEntry* gGenericReputationEntries = NULL;

// 0x518548
static int gGenericReputationEntriesLength = 0;

// 0x51854C
static const TownReputationEntry gTownReputationEntries[TOWN_REPUTATION_COUNT] = {
    { GVAR_TOWN_REP_ARROYO, CITY_ARROYO },
    { GVAR_TOWN_REP_KLAMATH, CITY_KLAMATH },
    { GVAR_TOWN_REP_THE_DEN, CITY_DEN },
    { GVAR_TOWN_REP_VAULT_CITY, CITY_VAULT_CITY },
    { GVAR_TOWN_REP_GECKO, CITY_GECKO },
    { GVAR_TOWN_REP_MODOC, CITY_MODOC },
    { GVAR_TOWN_REP_SIERRA_BASE, CITY_SIERRA_ARMY_BASE },
    { GVAR_TOWN_REP_BROKEN_HILLS, CITY_BROKEN_HILLS },
    { GVAR_TOWN_REP_NEW_RENO, CITY_NEW_RENO },
    { GVAR_TOWN_REP_REDDING, CITY_REDDING },
    { GVAR_TOWN_REP_NCR, CITY_NEW_CALIFORNIA_REPUBLIC },
    { GVAR_TOWN_REP_VAULT_13, CITY_VAULT_13 },
    { GVAR_TOWN_REP_SAN_FRANCISCO, CITY_SAN_FRANCISCO },
    { GVAR_TOWN_REP_ABBEY, CITY_ABBEY },
    { GVAR_TOWN_REP_EPA, CITY_ENV_PROTECTION_AGENCY },
    { GVAR_TOWN_REP_PRIMITIVE_TRIBE, CITY_PRIMITIVE_TRIBE },
    { GVAR_TOWN_REP_RAIDERS, CITY_RAIDERS },
    { GVAR_TOWN_REP_VAULT_15, CITY_VAULT_15 },
    { GVAR_TOWN_REP_GHOST_FARM, CITY_MODOC_GHOST_TOWN },
};

// 0x5185E4
static const int gAddictionReputationVars[ADDICTION_REPUTATION_COUNT] = {
    GVAR_NUKA_COLA_ADDICT,
    GVAR_BUFF_OUT_ADDICT,
    GVAR_MENTATS_ADDICT,
    GVAR_PSYCHO_ADDICT,
    GVAR_RADAWAY_ADDICT,
    GVAR_ALCOHOL_ADDICT,
    GVAR_ADDICT_JET,
    GVAR_ADDICT_TRAGIC,
};

// 0x518604
static const int gAddictionReputationFrmIds[ADDICTION_REPUTATION_COUNT] = {
    142,
    126,
    140,
    144,
    145,
    52,
    136,
    149,
};

// 0x518624
static int gCharacterEditorFolderViewScrollUpBtn = -1;

// 0x518628
static int gCharacterEditorFolderViewScrollDownBtn = -1;

// 0x56FB60
static char gCharacterEditorFolderCardString[256];

// 0x56FC60
static int gCharacterEditorSkillsBackup[SKILL_COUNT];

// 0x56FCA8
static MessageList gCharacterEditorMessageList;

// 0x56FCB0
static PerkDialogOption gPerkDialogOptionList[DIALOG_PICKER_NUM_OPTIONS];

// buttons for selecting traits
//
// 0x5700A8
static int gCharacterEditorOptionalTraitBtns[TRAIT_COUNT];

// 0x5700E8
static MessageListItem gCharacterEditorMessageListItem;

// 0x5700F8
static char gCharacterEditorCardTitle[48];

// 0x570128
static char gPerkDialogCardTitle[48];

// buttons for tagging skills
//
// 0x570158
static int gCharacterEditorTagSkillBtns[SKILL_COUNT];

// pc name
//
// 0x5701A0
static char gCharacterEditorNameBackup[32];

// 0x5701C0
static Size gCharacterEditorFrmSize[EDITOR_GRAPHIC_COUNT];

// 0x570350
static CacheEntry* gCharacterEditorFrmHandle[EDITOR_GRAPHIC_COUNT];

// 0x570418
static unsigned char* gCharacterEditorFrmCopy[EDITOR_GRAPHIC_COUNT];

// 0x5704E0
static unsigned char* gCharacterEditorFrmData[EDITOR_GRAPHIC_COUNT];

// 0x5705A8
static int gCharacterEditorFolderViewMaxLines;

// 0x5705AC
static int gCharacterEditorFolderViewCurrentLine;

// 0x5705B0
static int gCharacterEditorFolderCardFrmId;

// 0x5705B4
static int gCharacterEditorFolderViewTopLine;

// 0x5705B8
static char* gCharacterEditorFolderCardTitle;

// 0x5705BC
static char* gCharacterEditorFolderCardSubtitle;

// 0x5705C0
static int gCharacterEditorFolderViewOffsetY;

// 0x5705C4
static int gCharacterEditorKarmaFolderTopLine;

// 0x5705C8
static int gCharacterEditorFolderViewHighlightedLine;

// 0x5705CC
static char* gCharacterEditorFolderCardDescription;

// 0x5705D0
static int gCharacterEditorFolderViewNextY;

// 0x5705D4
static int gCharacterEditorKillsFolderTopLine;

// 0x5705D8
static int gCharacterEditorPerkFolderTopLine;

// 0x5705DC
static unsigned char* gPerkDialogBackgroundBuffer;

// 0x5705E0
static int gPerkDialogWindow;

// 0x5705E4
static int gCharacterEditorSliderPlusBtn;

// 0x5705E8
static int gCharacterEditorSliderMinusBtn;

// - stats buttons
//
// 0x5705EC
static int gCharacterEditorPrimaryStatMinusBtns[7];

// 0x570608
static unsigned char* gCharacterEditorWindowBuffer;

// 0x57060C
static int gCharacterEditorWindow;

// + stats buttons
//
// 0x570610
static int gCharacterEditorPrimaryStatPlusBtns[7];

// 0x57062C
static unsigned char* gPerkDialogWindowBuffer;

// 0x570630
static CritterProtoData gCharacterEditorDudeDataBackup;

// 0x5707A4
static unsigned char* gCharacterEditorWindowBackgroundBuffer;

// 0x5707A8
static int gPerkDialogCurrentLine;

// 0x5707AC
static int gPerkDialogPreviousCurrentLine;

// unspent skill points
//
// 0x5707B0
static int gCharacterEditorUnspentSkillPointsBackup;

// 0x5707B4
static int gCharacterEditorLastLevel;

// 0x5707B8
static int gCharacterEditorOldFont;

// 0x5707BC
static int gCharacterEditorKillsCount;

// character editor background
//
// 0x5707C0
static CacheEntry* gCharacterEditorWindowBackgroundHandle;

// current hit points
//
// 0x5707C4
static int gCharacterEditorHitPointsBackup;

// 0x5707C8
static int gCharacterEditorMouseY; // mouse y

// 0x5707CC
static int gCharacterEditorMouseX; // mouse x

// 0x5707D0
static int characterEditorSelectedItem;

// 0x5707D4
static int characterEditorWindowSelectedFolder;

// 0x5707D8
static bool gCharacterEditorCardDrawn;

// 0x5707DC
static int gPerkDialogTopLine;

// 0x5707E0
static bool gPerkDialogCardDrawn;

// 0x5707E4
static int gCharacterEditorPerksBackup[PERK_COUNT];

// 0x5709C0
static unsigned int _repFtime;

// 0x5709C4
static unsigned int _frame_time;

// 0x5709C8
static int gCharacterEditorOldTaggedSkillCount;

// 0x5709CC
static int gCharacterEditorLastLevelBackup;

// 0x5709E8
static int gPerkDialogCardFrmId;

// 0x5709EC
static int gCharacterEditorCardFrmId;

// 0x5709D0
static bool gCharacterEditorIsCreationMode;

// 0x5709D4
static int gCharacterEditorTaggedSkillsBackup[NUM_TAGGED_SKILLS];

// 0x5709F0
static int gCharacterEditorOptionalTraitsBackup[3];

// current index for selecting new trait
//
// 0x5709FC
static int gCharacterEditorTempTraitCount;

// 0x570A00
static int gPerkDialogOptionCount;

// 0x570A04
static int gCharacterEditorTempTraits[3];

// 0x570A10
static int gCharacterEditorTaggedSkillCount;

// 0x570A14
static int gCharacterEditorTempTaggedSkills[NUM_TAGGED_SKILLS];

// 0x570A28
static char gCharacterEditorHasFreePerkBackup;

// 0x570A29
static unsigned char gCharacterEditorHasFreePerk;

// 0x570A2A
static unsigned char gCharacterEditorIsSkillsFirstDraw;

struct CustomKarmaFolderDescription {
    int frmId;
    int threshold;
};

static std::vector<CustomKarmaFolderDescription> gCustomKarmaFolderDescriptions;

// 0x431DF8
int characterEditorShow(bool isCreationMode)
{
    char* messageListItemText;
    char line1[128];
    char line2[128];
    const char* lines[] = { line2 };

    gCharacterEditorIsCreationMode = isCreationMode;

    characterEditorSavePlayer();

    if (characterEditorWindowInit() == -1) {
        debugPrint("\n ** Error loading character editor data! **\n");
        return -1;
    }

    if (!gCharacterEditorIsCreationMode) {
        if (characterEditorUpdateLevel()) {
            critterUpdateDerivedStats(gDude);
            characterEditorDrawOptionalTraits();
            characterEditorDrawSkills(0);
            characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
            characterEditorDrawDerivedStats();
            characterEditorDrawCard();
        }
    }

    int rc = -1;
    while (rc == -1) {
        _frame_time = _get_time();
        int keyCode = _get_input();

        bool done = false;
        if (keyCode == 500) {
            done = true;
        }

        if (keyCode == KEY_RETURN || keyCode == KEY_UPPERCASE_D || keyCode == KEY_LOWERCASE_D) {
            done = true;
            soundPlayFile("ib1p1xx1");
        }

        if (done) {
            if (gCharacterEditorIsCreationMode) {
                if (gCharacterEditorRemainingCharacterPoints != 0) {
                    soundPlayFile("iisxxxx1");

                    // You must use all character points
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 118);
                    strcpy(line1, messageListItemText);

                    // before starting the game!
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 119);
                    strcpy(line2, messageListItemText);

                    showDialogBox(line1, lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], 0);
                    windowRefresh(gCharacterEditorWindow);

                    rc = -1;
                    continue;
                }

                if (gCharacterEditorTaggedSkillCount > 0) {
                    soundPlayFile("iisxxxx1");

                    // You must select all tag skills
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 142);
                    strcpy(line1, messageListItemText);

                    // before starting the game!
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 143);
                    strcpy(line2, messageListItemText);

                    showDialogBox(line1, lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], 0);
                    windowRefresh(gCharacterEditorWindow);

                    rc = -1;
                    continue;
                }

                if (_is_supper_bonus()) {
                    soundPlayFile("iisxxxx1");

                    // All stats must be between 1 and 10
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 157);
                    strcpy(line1, messageListItemText);

                    // before starting the game!
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 158);
                    strcpy(line2, messageListItemText);

                    showDialogBox(line1, lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], 0);
                    windowRefresh(gCharacterEditorWindow);

                    rc = -1;
                    continue;
                }

                if (compat_stricmp(critterGetName(gDude), "None") == 0) {
                    soundPlayFile("iisxxxx1");

                    // Warning: You haven't changed your player
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 160);
                    strcpy(line1, messageListItemText);

                    // name. Use this character any way?
                    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 161);
                    strcpy(line2, messageListItemText);

                    if (showDialogBox(line1, lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], DIALOG_BOX_YES_NO) == 0) {
                        windowRefresh(gCharacterEditorWindow);

                        rc = -1;
                        continue;
                    }
                }
            }

            windowRefresh(gCharacterEditorWindow);
            rc = 0;
        } else if (keyCode == KEY_CTRL_Q || keyCode == KEY_CTRL_X || keyCode == KEY_F10) {
            showQuitConfirmationDialog();
            windowRefresh(gCharacterEditorWindow);
        } else if (keyCode == 502 || keyCode == KEY_ESCAPE || keyCode == KEY_UPPERCASE_C || keyCode == KEY_LOWERCASE_C || _game_user_wants_to_quit != 0) {
            windowRefresh(gCharacterEditorWindow);
            rc = 1;
        } else if (gCharacterEditorIsCreationMode && (keyCode == 517 || keyCode == KEY_UPPERCASE_N || keyCode == KEY_LOWERCASE_N)) {
            characterEditorEditName();
            windowRefresh(gCharacterEditorWindow);
        } else if (gCharacterEditorIsCreationMode && (keyCode == 519 || keyCode == KEY_UPPERCASE_A || keyCode == KEY_LOWERCASE_A)) {
            characterEditorEditAge();
            windowRefresh(gCharacterEditorWindow);
        } else if (gCharacterEditorIsCreationMode && (keyCode == 520 || keyCode == KEY_UPPERCASE_S || keyCode == KEY_LOWERCASE_S)) {
            characterEditorEditGender();
            windowRefresh(gCharacterEditorWindow);
        } else if (gCharacterEditorIsCreationMode && (keyCode >= 503 && keyCode < 517)) {
            characterEditorAdjustPrimaryStat(keyCode);
            windowRefresh(gCharacterEditorWindow);
        } else if ((gCharacterEditorIsCreationMode && (keyCode == 501 || keyCode == KEY_UPPERCASE_O || keyCode == KEY_LOWERCASE_O))
            || (!gCharacterEditorIsCreationMode && (keyCode == 501 || keyCode == KEY_UPPERCASE_P || keyCode == KEY_LOWERCASE_P))) {
            characterEditorShowOptions();
            windowRefresh(gCharacterEditorWindow);
        } else if (keyCode >= 525 && keyCode < 535) {
            characterEditorHandleInfoButtonPressed(keyCode);
            windowRefresh(gCharacterEditorWindow);
        } else {
            switch (keyCode) {
            case KEY_TAB:
                if (characterEditorSelectedItem >= 0 && characterEditorSelectedItem < 7) {
                    characterEditorSelectedItem = gCharacterEditorIsCreationMode ? 82 : 7;
                } else if (characterEditorSelectedItem >= 7 && characterEditorSelectedItem < 9) {
                    if (gCharacterEditorIsCreationMode) {
                        characterEditorSelectedItem = 82;
                    } else {
                        characterEditorSelectedItem = 10;
                        characterEditorWindowSelectedFolder = 0;
                    }
                } else if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43) {
                    switch (characterEditorWindowSelectedFolder) {
                    case EDITOR_FOLDER_PERKS:
                        characterEditorSelectedItem = 10;
                        characterEditorWindowSelectedFolder = EDITOR_FOLDER_KARMA;
                        break;
                    case EDITOR_FOLDER_KARMA:
                        characterEditorSelectedItem = 10;
                        characterEditorWindowSelectedFolder = EDITOR_FOLDER_KILLS;
                        break;
                    case EDITOR_FOLDER_KILLS:
                        characterEditorSelectedItem = 43;
                        break;
                    }
                } else if (characterEditorSelectedItem >= 43 && characterEditorSelectedItem < 51) {
                    characterEditorSelectedItem = 51;
                } else if (characterEditorSelectedItem >= 51 && characterEditorSelectedItem < 61) {
                    characterEditorSelectedItem = 61;
                } else if (characterEditorSelectedItem >= 61 && characterEditorSelectedItem < 82) {
                    characterEditorSelectedItem = 0;
                } else if (characterEditorSelectedItem >= 82 && characterEditorSelectedItem < 98) {
                    characterEditorSelectedItem = 43;
                }
                characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
                characterEditorDrawOptionalTraits();
                characterEditorDrawSkills(0);
                characterEditorDrawPcStats();
                characterEditorDrawFolders();
                characterEditorDrawDerivedStats();
                characterEditorDrawCard();
                windowRefresh(gCharacterEditorWindow);
                break;
            case KEY_ARROW_LEFT:
            case KEY_MINUS:
            case KEY_UPPERCASE_J:
                if (characterEditorSelectedItem >= 0 && characterEditorSelectedItem < 7) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorPrimaryStatMinusBtns[characterEditorSelectedItem]);
                        windowRefresh(gCharacterEditorWindow);
                    }
                } else if (characterEditorSelectedItem >= 61 && characterEditorSelectedItem < 79) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorTagSkillBtns[gCharacterEditorIsCreationMode - 61]);
                        windowRefresh(gCharacterEditorWindow);
                    } else {
                        characterEditorHandleAdjustSkillButtonPressed(keyCode);
                        windowRefresh(gCharacterEditorWindow);
                    }
                } else if (characterEditorSelectedItem >= 82 && characterEditorSelectedItem < 98) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorOptionalTraitBtns[gCharacterEditorIsCreationMode - 82]);
                        windowRefresh(gCharacterEditorWindow);
                    }
                }
                break;
            case KEY_ARROW_RIGHT:
            case KEY_PLUS:
            case KEY_UPPERCASE_N:
                if (characterEditorSelectedItem >= 0 && characterEditorSelectedItem < 7) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorPrimaryStatPlusBtns[characterEditorSelectedItem]);
                        windowRefresh(gCharacterEditorWindow);
                    }
                } else if (characterEditorSelectedItem >= 61 && characterEditorSelectedItem < 79) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorTagSkillBtns[gCharacterEditorIsCreationMode - 61]);
                        windowRefresh(gCharacterEditorWindow);
                    } else {
                        characterEditorHandleAdjustSkillButtonPressed(keyCode);
                        windowRefresh(gCharacterEditorWindow);
                    }
                } else if (characterEditorSelectedItem >= 82 && characterEditorSelectedItem < 98) {
                    if (gCharacterEditorIsCreationMode) {
                        _win_button_press_and_release(gCharacterEditorOptionalTraitBtns[gCharacterEditorIsCreationMode - 82]);
                        windowRefresh(gCharacterEditorWindow);
                    }
                }
                break;
            case KEY_ARROW_UP:
                if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43) {
                    if (characterEditorSelectedItem == 10) {
                        if (gCharacterEditorFolderViewTopLine > 0) {
                            characterEditorFolderViewScroll(-1);
                            characterEditorSelectedItem--;
                            characterEditorDrawFolders();
                            characterEditorDrawCard();
                        }
                    } else {
                        characterEditorSelectedItem--;
                        characterEditorDrawFolders();
                        characterEditorDrawCard();
                    }

                    windowRefresh(gCharacterEditorWindow);
                } else {
                    switch (characterEditorSelectedItem) {
                    case 0:
                        characterEditorSelectedItem = 6;
                        break;
                    case 7:
                        characterEditorSelectedItem = 9;
                        break;
                    case 43:
                        characterEditorSelectedItem = 50;
                        break;
                    case 51:
                        characterEditorSelectedItem = 60;
                        break;
                    case 61:
                        characterEditorSelectedItem = 78;
                        break;
                    case 82:
                        characterEditorSelectedItem = 97;
                        break;
                    default:
                        characterEditorSelectedItem -= 1;
                        break;
                    }

                    if (characterEditorSelectedItem >= 61 && characterEditorSelectedItem < 79) {
                        gCharacterEditorCurrentSkill = characterEditorSelectedItem - 61;
                    }

                    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
                    characterEditorDrawOptionalTraits();
                    characterEditorDrawSkills(0);
                    characterEditorDrawPcStats();
                    characterEditorDrawFolders();
                    characterEditorDrawDerivedStats();
                    characterEditorDrawCard();
                    windowRefresh(gCharacterEditorWindow);
                }
                break;
            case KEY_ARROW_DOWN:
                if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43) {
                    if (characterEditorSelectedItem - 10 < gCharacterEditorFolderViewCurrentLine - gCharacterEditorFolderViewTopLine) {
                        if (characterEditorSelectedItem - 10 == gCharacterEditorFolderViewMaxLines - 1) {
                            characterEditorFolderViewScroll(1);
                        }

                        characterEditorSelectedItem++;

                        characterEditorDrawFolders();
                        characterEditorDrawCard();
                    }

                    windowRefresh(gCharacterEditorWindow);
                } else {
                    switch (characterEditorSelectedItem) {
                    case 6:
                        characterEditorSelectedItem = 0;
                        break;
                    case 9:
                        characterEditorSelectedItem = 7;
                        break;
                    case 50:
                        characterEditorSelectedItem = 43;
                        break;
                    case 60:
                        characterEditorSelectedItem = 51;
                        break;
                    case 78:
                        characterEditorSelectedItem = 61;
                        break;
                    case 97:
                        characterEditorSelectedItem = 82;
                        break;
                    default:
                        characterEditorSelectedItem += 1;
                        break;
                    }

                    if (characterEditorSelectedItem >= 61 && characterEditorSelectedItem < 79) {
                        gCharacterEditorCurrentSkill = characterEditorSelectedItem - 61;
                    }

                    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
                    characterEditorDrawOptionalTraits();
                    characterEditorDrawSkills(0);
                    characterEditorDrawPcStats();
                    characterEditorDrawFolders();
                    characterEditorDrawDerivedStats();
                    characterEditorDrawCard();
                    windowRefresh(gCharacterEditorWindow);
                }
                break;
            case 521:
            case 523:
                characterEditorHandleAdjustSkillButtonPressed(keyCode);
                windowRefresh(gCharacterEditorWindow);
                break;
            case 535:
                characterEditorHandleFolderButtonPressed();
                windowRefresh(gCharacterEditorWindow);
                break;
            case 17000:
                characterEditorFolderViewScroll(-1);
                windowRefresh(gCharacterEditorWindow);
                break;
            case 17001:
                characterEditorFolderViewScroll(1);
                windowRefresh(gCharacterEditorWindow);
                break;
            default:
                if (gCharacterEditorIsCreationMode && (keyCode >= 536 && keyCode < 554)) {
                    characterEditorToggleTaggedSkill(keyCode - 536);
                    windowRefresh(gCharacterEditorWindow);
                } else if (gCharacterEditorIsCreationMode && (keyCode >= 555 && keyCode < 571)) {
                    characterEditorToggleOptionalTrait(keyCode - 555);
                    windowRefresh(gCharacterEditorWindow);
                } else {
                    if (keyCode == 390) {
                        takeScreenshot();
                    }

                    windowRefresh(gCharacterEditorWindow);
                }
            }
        }
    }

    if (rc == 0) {
        if (isCreationMode) {
            _proto_dude_update_gender();
            paletteFadeTo(gPaletteBlack);
        }
    }

    characterEditorWindowFree();

    if (rc == 1) {
        characterEditorRestorePlayer();
    }

    if (dudeHasState(0x03)) {
        dudeDisableState(0x03);
    }

    interfaceRenderHitPoints(false);

    return rc;
}

// 0x4329EC
static int characterEditorWindowInit()
{
    int i;
    int v1;
    int v3;
    char path[COMPAT_MAX_PATH];
    int fid;
    char* str;
    int len;
    int btn;
    int x;
    int y;
    char perks[32];
    char karma[32];
    char kills[32];

    gCharacterEditorOldFont = fontGetCurrent();
    gCharacterEditorOldTaggedSkillCount = 0;
    gCharacterEditorIsoWasEnabled = 0;
    gPerkDialogCardFrmId = -1;
    gCharacterEditorCardFrmId = -1;
    gPerkDialogCardDrawn = false;
    gCharacterEditorCardDrawn = false;
    gCharacterEditorIsSkillsFirstDraw = 1;
    gPerkDialogCardTitle[0] = '\0';
    gCharacterEditorCardTitle[0] = '\0';

    fontSetCurrent(101);

    gCharacterEditorSkillValueAdjustmentSliderY = gCharacterEditorCurrentSkill * (fontGetLineHeight() + 1) + 27;

    // skills
    skillsGetTagged(gCharacterEditorTempTaggedSkills, NUM_TAGGED_SKILLS);

    v1 = 0;
    for (i = 3; i >= 0; i--) {
        if (gCharacterEditorTempTaggedSkills[i] != -1) {
            break;
        }

        v1++;
    }

    if (gCharacterEditorIsCreationMode) {
        v1--;
    }

    gCharacterEditorTaggedSkillCount = v1;

    // traits
    traitsGetSelected(&(gCharacterEditorTempTraits[0]), &(gCharacterEditorTempTraits[1]));

    v3 = 0;
    for (i = 1; i >= 0; i--) {
        if (gCharacterEditorTempTraits[i] != -1) {
            break;
        }

        v3++;
    }

    gCharacterEditorTempTraitCount = v3;

    if (!gCharacterEditorIsCreationMode) {
        gCharacterEditorIsoWasEnabled = isoDisable();
    }

    colorCycleDisable();
    gameMouseSetCursor(MOUSE_CURSOR_ARROW);

    if (!messageListInit(&gCharacterEditorMessageList)) {
        return -1;
    }

    sprintf(path, "%s%s", asc_5186C8, "editor.msg");

    if (!messageListLoad(&gCharacterEditorMessageList, path)) {
        return -1;
    }

    fid = buildFid(OBJ_TYPE_INTERFACE, (gCharacterEditorIsCreationMode ? 169 : 177), 0, 0, 0);
    gCharacterEditorWindowBackgroundBuffer = artLockFrameDataReturningSize(fid, &gCharacterEditorWindowBackgroundHandle, &(gCharacterEditorFrmSize[0].width), &(gCharacterEditorFrmSize[0].height));
    if (gCharacterEditorWindowBackgroundBuffer == NULL) {
        messageListFree(&gCharacterEditorMessageList);
        return -1;
    }

    if (karmaInit() == -1) {
        return -1;
    }

    if (genericReputationInit() == -1) {
        return -1;
    }

    // SFALL: Custom karma folder.
    customKarmaFolderInit();

    soundContinueAll();

    for (i = 0; i < EDITOR_GRAPHIC_COUNT; i++) {
        fid = buildFid(OBJ_TYPE_INTERFACE, gCharacterEditorFrmIds[i], 0, 0, 0);
        gCharacterEditorFrmData[i] = artLockFrameDataReturningSize(fid, &(gCharacterEditorFrmHandle[i]), &(gCharacterEditorFrmSize[i].width), &(gCharacterEditorFrmSize[i].height));
        if (gCharacterEditorFrmData[i] == NULL) {
            break;
        }
    }

    if (i != EDITOR_GRAPHIC_COUNT) {
        while (--i >= 0) {
            artUnlock(gCharacterEditorFrmHandle[i]);
        }
        return -1;

        artUnlock(gCharacterEditorWindowBackgroundHandle);

        messageListFree(&gCharacterEditorMessageList);

        if (gCharacterEditorIsoWasEnabled) {
            isoEnable();
        }

        colorCycleEnable();
        gameMouseSetCursor(MOUSE_CURSOR_ARROW);
        return -1;
    }

    soundContinueAll();

    for (i = 0; i < EDITOR_GRAPHIC_COUNT; i++) {
        if (gCharacterEditorFrmShouldCopy[i]) {
            gCharacterEditorFrmCopy[i] = (unsigned char*)internal_malloc(gCharacterEditorFrmSize[i].width * gCharacterEditorFrmSize[i].height);
            if (gCharacterEditorFrmCopy[i] == NULL) {
                break;
            }
            memcpy(gCharacterEditorFrmCopy[i], gCharacterEditorFrmData[i], gCharacterEditorFrmSize[i].width * gCharacterEditorFrmSize[i].height);
        } else {
            gCharacterEditorFrmCopy[i] = (unsigned char*)-1;
        }
    }

    if (i != EDITOR_GRAPHIC_COUNT) {
        while (--i >= 0) {
            if (gCharacterEditorFrmShouldCopy[i]) {
                internal_free(gCharacterEditorFrmCopy[i]);
            }
        }

        for (i = 0; i < EDITOR_GRAPHIC_COUNT; i++) {
            artUnlock(gCharacterEditorFrmHandle[i]);
        }

        artUnlock(gCharacterEditorWindowBackgroundHandle);

        messageListFree(&gCharacterEditorMessageList);
        if (gCharacterEditorIsoWasEnabled) {
            isoEnable();
        }

        colorCycleEnable();
        gameMouseSetCursor(MOUSE_CURSOR_ARROW);

        return -1;
    }

    int editorWindowX = (screenGetWidth() - EDITOR_WINDOW_WIDTH) / 2;
    int editorWindowY = (screenGetHeight() - EDITOR_WINDOW_HEIGHT) / 2;
    gCharacterEditorWindow = windowCreate(editorWindowX,
        editorWindowY,
        EDITOR_WINDOW_WIDTH,
        EDITOR_WINDOW_HEIGHT,
        256,
        WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);
    if (gCharacterEditorWindow == -1) {
        for (i = 0; i < EDITOR_GRAPHIC_COUNT; i++) {
            if (gCharacterEditorFrmShouldCopy[i]) {
                internal_free(gCharacterEditorFrmCopy[i]);
            }
            artUnlock(gCharacterEditorFrmHandle[i]);
        }

        artUnlock(gCharacterEditorWindowBackgroundHandle);

        messageListFree(&gCharacterEditorMessageList);
        if (gCharacterEditorIsoWasEnabled) {
            isoEnable();
        }

        colorCycleEnable();
        gameMouseSetCursor(MOUSE_CURSOR_ARROW);

        return -1;
    }

    gCharacterEditorWindowBuffer = windowGetBuffer(gCharacterEditorWindow);
    memcpy(gCharacterEditorWindowBuffer, gCharacterEditorWindowBackgroundBuffer, 640 * 480);

    if (gCharacterEditorIsCreationMode) {
        fontSetCurrent(103);

        // CHAR POINTS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 116);
        fontDrawText(gCharacterEditorWindowBuffer + (286 * 640) + 14, str, 640, 640, _colorTable[18979]);
        characterEditorDrawBigNumber(126, 282, 0, gCharacterEditorRemainingCharacterPoints, 0, gCharacterEditorWindow);

        // OPTIONS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 101);
        fontDrawText(gCharacterEditorWindowBuffer + (454 * 640) + 363, str, 640, 640, _colorTable[18979]);

        // OPTIONAL TRAITS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 139);
        fontDrawText(gCharacterEditorWindowBuffer + (326 * 640) + 52, str, 640, 640, _colorTable[18979]);
        characterEditorDrawBigNumber(522, 228, 0, gPerkDialogOptionCount, 0, gCharacterEditorWindow);

        // TAG SKILLS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 138);
        fontDrawText(gCharacterEditorWindowBuffer + (233 * 640) + 422, str, 640, 640, _colorTable[18979]);
        characterEditorDrawBigNumber(522, 228, 0, gCharacterEditorTaggedSkillCount, 0, gCharacterEditorWindow);
    } else {
        fontSetCurrent(103);

        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 109);
        strcpy(perks, str);

        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 110);
        strcpy(karma, str);

        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 111);
        strcpy(kills, str);

        // perks selected
        len = fontGetStringWidth(perks);
        fontDrawText(
            gCharacterEditorFrmCopy[46] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 61 - len / 2,
            perks,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[18979]);

        len = fontGetStringWidth(karma);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 159 - len / 2,
            karma,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[14723]);

        len = fontGetStringWidth(kills);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 257 - len / 2,
            kills,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[14723]);

        // karma selected
        len = fontGetStringWidth(perks);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KARMA_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 61 - len / 2,
            perks,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[14723]);

        len = fontGetStringWidth(karma);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KARMA_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 159 - len / 2,
            karma,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[18979]);

        len = fontGetStringWidth(kills);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KARMA_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 257 - len / 2,
            kills,
            gCharacterEditorFrmSize[46].width,
            gCharacterEditorFrmSize[46].width,
            _colorTable[14723]);

        // kills selected
        len = fontGetStringWidth(perks);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KILLS_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 61 - len / 2,
            perks,
            gCharacterEditorFrmSize[46].width,
            gCharacterEditorFrmSize[46].width,
            _colorTable[14723]);

        len = fontGetStringWidth(karma);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KILLS_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 159 - len / 2,
            karma,
            gCharacterEditorFrmSize[46].width,
            gCharacterEditorFrmSize[46].width,
            _colorTable[14723]);

        len = fontGetStringWidth(kills);
        fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KILLS_FOLDER_SELECTED] + 5 * gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width + 257 - len / 2,
            kills,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            _colorTable[18979]);

        characterEditorDrawFolders();

        fontSetCurrent(103);

        // PRINT
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 103);
        fontDrawText(gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * PRINT_BTN_Y) + PRINT_BTN_X, str, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_WIDTH, _colorTable[18979]);

        characterEditorDrawPcStats();
        characterEditorFolderViewInit();
    }

    fontSetCurrent(103);

    // CANCEL
    str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 102);
    fontDrawText(gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * CANCEL_BTN_Y) + CANCEL_BTN_X, str, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_WIDTH, _colorTable[18979]);

    // DONE
    str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 100);
    fontDrawText(gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * DONE_BTN_Y) + DONE_BTN_X, str, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_WIDTH, _colorTable[18979]);

    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
    characterEditorDrawDerivedStats();

    if (!gCharacterEditorIsCreationMode) {
        gCharacterEditorSliderPlusBtn = buttonCreate(
            gCharacterEditorWindow,
            614,
            20,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].height,
            -1,
            522,
            521,
            522,
            gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_OFF],
            gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_ON],
            0,
            96);
        gCharacterEditorSliderMinusBtn = buttonCreate(
            gCharacterEditorWindow,
            614,
            20 + gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].height - 1,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_OFF].height,
            -1,
            524,
            523,
            524,
            gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_OFF],
            gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_ON],
            0,
            96);
        buttonSetCallbacks(gCharacterEditorSliderPlusBtn, _gsound_red_butt_press, NULL);
        buttonSetCallbacks(gCharacterEditorSliderMinusBtn, _gsound_red_butt_press, NULL);
    }

    characterEditorDrawSkills(0);
    characterEditorDrawCard();
    soundContinueAll();
    characterEditorDrawName();
    characterEditorDrawAge();
    characterEditorDrawGender();

    if (gCharacterEditorIsCreationMode) {
        x = NAME_BUTTON_X;
        btn = buttonCreate(
            gCharacterEditorWindow,
            x,
            NAME_BUTTON_Y,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].height,
            -1,
            -1,
            -1,
            NAME_BTN_CODE,
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_OFF],
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_ON],
            0,
            32);
        if (btn != -1) {
            buttonSetMask(btn, gCharacterEditorFrmData[EDITOR_GRAPHIC_NAME_MASK]);
            buttonSetCallbacks(btn, _gsound_lrg_butt_press, NULL);
        }

        x += gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width;
        btn = buttonCreate(
            gCharacterEditorWindow,
            x,
            NAME_BUTTON_Y,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].height,
            -1,
            -1,
            -1,
            AGE_BTN_CODE,
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_OFF],
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_ON],
            0,
            32);
        if (btn != -1) {
            buttonSetMask(btn, gCharacterEditorFrmData[EDITOR_GRAPHIC_AGE_MASK]);
            buttonSetCallbacks(btn, _gsound_lrg_butt_press, NULL);
        }

        x += gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width;
        btn = buttonCreate(
            gCharacterEditorWindow,
            x,
            NAME_BUTTON_Y,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].height,
            -1,
            -1,
            -1,
            SEX_BTN_CODE,
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_OFF],
            gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_ON],
            0,
            32);
        if (btn != -1) {
            buttonSetMask(btn, gCharacterEditorFrmData[EDITOR_GRAPHIC_SEX_MASK]);
            buttonSetCallbacks(btn, _gsound_lrg_butt_press, NULL);
        }

        y = TAG_SKILLS_BUTTON_Y;
        for (i = 0; i < SKILL_COUNT; i++) {
            gCharacterEditorTagSkillBtns[i] = buttonCreate(
                gCharacterEditorWindow,
                TAG_SKILLS_BUTTON_X,
                y,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].width,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height,
                -1,
                -1,
                -1,
                TAG_SKILLS_BUTTON_CODE + i,
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_OFF],
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON],
                NULL,
                32);
            y += gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height;
        }

        y = OPTIONAL_TRAITS_BTN_Y;
        for (i = 0; i < TRAIT_COUNT / 2; i++) {
            gCharacterEditorOptionalTraitBtns[i] = buttonCreate(
                gCharacterEditorWindow,
                OPTIONAL_TRAITS_LEFT_BTN_X,
                y,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].width,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height,
                -1,
                -1,
                -1,
                OPTIONAL_TRAITS_BTN_CODE + i,
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_OFF],
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON],
                NULL,
                32);
            y += gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height + OPTIONAL_TRAITS_BTN_SPACE;
        }

        y = OPTIONAL_TRAITS_BTN_Y;
        for (i = TRAIT_COUNT / 2; i < TRAIT_COUNT; i++) {
            gCharacterEditorOptionalTraitBtns[i] = buttonCreate(
                gCharacterEditorWindow,
                OPTIONAL_TRAITS_RIGHT_BTN_X,
                y,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].width,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height,
                -1,
                -1,
                -1,
                OPTIONAL_TRAITS_BTN_CODE + i,
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_OFF],
                gCharacterEditorFrmData[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON],
                NULL,
                32);
            y += gCharacterEditorFrmSize[EDITOR_GRAPHIC_TAG_SKILL_BUTTON_ON].height + OPTIONAL_TRAITS_BTN_SPACE;
        }

        characterEditorDrawOptionalTraits();
    } else {
        x = NAME_BUTTON_X;
        blitBufferToBufferTrans(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_OFF],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width,
            gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * NAME_BUTTON_Y) + x,
            EDITOR_WINDOW_WIDTH);

        x += gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width;
        blitBufferToBufferTrans(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_OFF],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width,
            gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * NAME_BUTTON_Y) + x,
            EDITOR_WINDOW_WIDTH);

        x += gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width;
        blitBufferToBufferTrans(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_OFF],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].width,
            gCharacterEditorWindowBuffer + (EDITOR_WINDOW_WIDTH * NAME_BUTTON_Y) + x,
            EDITOR_WINDOW_WIDTH);

        btn = buttonCreate(gCharacterEditorWindow,
            11,
            327,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_FOLDER_MASK].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_FOLDER_MASK].height,
            -1,
            -1,
            -1,
            535,
            NULL,
            NULL,
            NULL,
            BUTTON_FLAG_TRANSPARENT);
        if (btn != -1) {
            buttonSetMask(btn, gCharacterEditorFrmData[EDITOR_GRAPHIC_FOLDER_MASK]);
        }
    }

    if (gCharacterEditorIsCreationMode) {
        // +/- buttons for stats
        for (i = 0; i < 7; i++) {
            gCharacterEditorPrimaryStatPlusBtns[i] = buttonCreate(gCharacterEditorWindow,
                SPECIAL_STATS_BTN_X,
                gCharacterEditorPrimaryStatY[i],
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].width,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].height,
                -1,
                518,
                503 + i,
                518,
                gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_OFF],
                gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_ON],
                NULL,
                32);
            if (gCharacterEditorPrimaryStatPlusBtns[i] != -1) {
                buttonSetCallbacks(gCharacterEditorPrimaryStatPlusBtns[i], _gsound_red_butt_press, NULL);
            }

            gCharacterEditorPrimaryStatMinusBtns[i] = buttonCreate(gCharacterEditorWindow,
                SPECIAL_STATS_BTN_X,
                gCharacterEditorPrimaryStatY[i] + gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].height - 1,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].width,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].height,
                -1,
                518,
                510 + i,
                518,
                gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_OFF],
                gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_ON],
                NULL,
                32);
            if (gCharacterEditorPrimaryStatMinusBtns[i] != -1) {
                buttonSetCallbacks(gCharacterEditorPrimaryStatMinusBtns[i], _gsound_red_butt_press, NULL);
            }
        }
    }

    characterEditorRegisterInfoAreas();
    soundContinueAll();

    btn = buttonCreate(
        gCharacterEditorWindow,
        343,
        454,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        501,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    btn = buttonCreate(
        gCharacterEditorWindow,
        552,
        454,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        502,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        0,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    btn = buttonCreate(
        gCharacterEditorWindow,
        455,
        454,
        gCharacterEditorFrmSize[23].width,
        gCharacterEditorFrmSize[23].height,
        -1,
        -1,
        -1,
        500,
        gCharacterEditorFrmData[23],
        gCharacterEditorFrmData[24],
        0,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    windowRefresh(gCharacterEditorWindow);
    indicatorBarHide();

    return 0;
}

// 0x433AA8
static void characterEditorWindowFree()
{
    if (gCharacterEditorFolderViewScrollDownBtn != -1) {
        buttonDestroy(gCharacterEditorFolderViewScrollDownBtn);
        gCharacterEditorFolderViewScrollDownBtn = -1;
    }

    if (gCharacterEditorFolderViewScrollUpBtn != -1) {
        buttonDestroy(gCharacterEditorFolderViewScrollUpBtn);
        gCharacterEditorFolderViewScrollUpBtn = -1;
    }

    windowDestroy(gCharacterEditorWindow);

    for (int index = 0; index < EDITOR_GRAPHIC_COUNT; index++) {
        artUnlock(gCharacterEditorFrmHandle[index]);

        if (gCharacterEditorFrmShouldCopy[index]) {
            internal_free(gCharacterEditorFrmCopy[index]);
        }
    }

    artUnlock(gCharacterEditorWindowBackgroundHandle);

    // NOTE: Uninline.
    genericReputationFree();

    // NOTE: Uninline.
    karmaFree();

    // SFALL: Custom karma folder.
    customKarmaFolderFree();

    messageListFree(&gCharacterEditorMessageList);

    interfaceBarRefresh();

    if (gCharacterEditorIsoWasEnabled) {
        isoEnable();
    }

    colorCycleEnable();
    gameMouseSetCursor(MOUSE_CURSOR_ARROW);

    fontSetCurrent(gCharacterEditorOldFont);

    if (gCharacterEditorIsCreationMode == 1) {
        skillsSetTagged(gCharacterEditorTempTaggedSkills, 3);
        traitsSetSelected(gCharacterEditorTempTraits[0], gCharacterEditorTempTraits[1]);
        characterEditorSelectedItem = 0;
        critterAdjustHitPoints(gDude, 1000);
    }

    indicatorBarShow();
}

// CharEditInit
// 0x433C0C
void characterEditorInit()
{
    int i;

    characterEditorSelectedItem = 0;
    gCharacterEditorCurrentSkill = 0;
    gCharacterEditorSkillValueAdjustmentSliderY = 27;
    gCharacterEditorHasFreePerk = 0;
    characterEditorWindowSelectedFolder = EDITOR_FOLDER_PERKS;

    for (i = 0; i < 2; i++) {
        gCharacterEditorTempTraits[i] = -1;
        gCharacterEditorOptionalTraitsBackup[i] = -1;
    }

    gCharacterEditorRemainingCharacterPoints = 5;
    gCharacterEditorLastLevel = 1;
}

// handle name input
static int _get_input_str(int win, int cancelKeyCode, char* text, int maxLength, int x, int y, int textColor, int backgroundColor, int flags)
{
    int cursorWidth = fontGetStringWidth("_") - 4;
    int windowWidth = windowGetWidth(win);
    int v60 = fontGetLineHeight();
    unsigned char* windowBuffer = windowGetBuffer(win);
    if (maxLength > 255) {
        maxLength = 255;
    }

    char copy[257];
    strcpy(copy, text);

    int nameLength = strlen(text);
    copy[nameLength] = ' ';
    copy[nameLength + 1] = '\0';

    int nameWidth = fontGetStringWidth(copy);

    bufferFill(windowBuffer + windowWidth * y + x, nameWidth, fontGetLineHeight(), windowWidth, backgroundColor);
    fontDrawText(windowBuffer + windowWidth * y + x, copy, windowWidth, windowWidth, textColor);

    windowRefresh(win);

    int blinkingCounter = 3;
    bool blink = false;

    int rc = 1;
    while (rc == 1) {
        _frame_time = _get_time();

        int keyCode = _get_input();
        if (keyCode == cancelKeyCode) {
            rc = 0;
        } else if (keyCode == KEY_RETURN) {
            soundPlayFile("ib1p1xx1");
            rc = 0;
        } else if (keyCode == KEY_ESCAPE || _game_user_wants_to_quit != 0) {
            rc = -1;
        } else {
            if ((keyCode == KEY_DELETE || keyCode == KEY_BACKSPACE) && nameLength >= 1) {
                bufferFill(windowBuffer + windowWidth * y + x, fontGetStringWidth(copy), v60, windowWidth, backgroundColor);
                copy[nameLength - 1] = ' ';
                copy[nameLength] = '\0';
                fontDrawText(windowBuffer + windowWidth * y + x, copy, windowWidth, windowWidth, textColor);
                nameLength--;

                windowRefresh(win);
            } else if ((keyCode >= KEY_FIRST_INPUT_CHARACTER && keyCode <= KEY_LAST_INPUT_CHARACTER) && nameLength < maxLength) {
                if ((flags & 0x01) != 0) {
                    if (!_isdoschar(keyCode)) {
                        break;
                    }
                }

                bufferFill(windowBuffer + windowWidth * y + x, fontGetStringWidth(copy), v60, windowWidth, backgroundColor);

                copy[nameLength] = keyCode & 0xFF;
                copy[nameLength + 1] = ' ';
                copy[nameLength + 2] = '\0';
                fontDrawText(windowBuffer + windowWidth * y + x, copy, windowWidth, windowWidth, textColor);
                nameLength++;

                windowRefresh(win);
            }
        }

        blinkingCounter -= 1;
        if (blinkingCounter == 0) {
            blinkingCounter = 3;

            int color = blink ? backgroundColor : textColor;
            blink = !blink;

            bufferFill(windowBuffer + windowWidth * y + x + fontGetStringWidth(copy) - cursorWidth, cursorWidth, v60 - 2, windowWidth, color);
        }

        windowRefresh(win);

        while (getTicksSince(_frame_time) < 1000 / 24) { }
    }

    if (rc == 0 || nameLength > 0) {
        copy[nameLength] = '\0';
        strcpy(text, copy);
    }

    return rc;
}

// 0x434060
bool _isdoschar(int ch)
{
    const char* punctuations = "#@!$`'~^&()-_=[]{}";

    if (isalnum(ch)) {
        return true;
    }

    int length = strlen(punctuations);
    for (int index = 0; index < length; index++) {
        if (punctuations[index] == ch) {
            return true;
        }
    }

    return false;
}

// copy filename replacing extension
//
// 0x4340D0
char* _strmfe(char* dest, const char* name, const char* ext)
{
    char* save = dest;

    while (*name != '\0' && *name != '.') {
        *dest++ = *name++;
    }

    *dest++ = '.';

    strcpy(dest, ext);

    return save;
}

// 0x43410C
static void characterEditorDrawFolders()
{
    if (gCharacterEditorIsCreationMode) {
        return;
    }

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + (360 * 640) + 34, 280, 120, 640, gCharacterEditorWindowBuffer + (360 * 640) + 34, 640);

    fontSetCurrent(101);

    switch (characterEditorWindowSelectedFolder) {
    case EDITOR_FOLDER_PERKS:
        blitBufferToBuffer(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorWindowBuffer + (327 * 640) + 11,
            640);
        characterEditorDrawPerksFolder();
        break;
    case EDITOR_FOLDER_KARMA:
        blitBufferToBuffer(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KARMA_FOLDER_SELECTED],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorWindowBuffer + (327 * 640) + 11,
            640);
        characterEditorDrawKarmaFolder();
        break;
    case EDITOR_FOLDER_KILLS:
        blitBufferToBuffer(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_KILLS_FOLDER_SELECTED],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_PERKS_FOLDER_SELECTED].width,
            gCharacterEditorWindowBuffer + (327 * 640) + 11,
            640);
        gCharacterEditorKillsCount = characterEditorDrawKillsFolder();
        break;
    default:
        debugPrint("\n ** Unknown folder type! **\n");
        break;
    }
}

// 0x434238
static void characterEditorDrawPerksFolder()
{
    const char* string;
    char perkName[80];
    int perk;
    int perkLevel;
    bool hasContent = false;

    characterEditorFolderViewClear();

    if (gCharacterEditorTempTraits[0] != -1) {
        // TRAITS
        string = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 156);
        if (characterEditorFolderViewDrawHeading(string)) {
            gCharacterEditorFolderCardFrmId = 54;
            // Optional Traits
            gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 146);
            gCharacterEditorFolderCardSubtitle = NULL;
            // Optional traits describe your character in more detail. All traits will have positive and negative effects. You may choose up to two traits during creation.
            gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 147);
            hasContent = true;
        }

        if (gCharacterEditorTempTraits[0] != -1) {
            string = traitGetName(gCharacterEditorTempTraits[0]);
            if (characterEditorFolderViewDrawString(string)) {
                gCharacterEditorFolderCardFrmId = traitGetFrmId(gCharacterEditorTempTraits[0]);
                gCharacterEditorFolderCardTitle = traitGetName(gCharacterEditorTempTraits[0]);
                gCharacterEditorFolderCardSubtitle = NULL;
                gCharacterEditorFolderCardDescription = traitGetDescription(gCharacterEditorTempTraits[0]);
                hasContent = true;
            }
        }

        if (gCharacterEditorTempTraits[1] != -1) {
            string = traitGetName(gCharacterEditorTempTraits[1]);
            if (characterEditorFolderViewDrawString(string)) {
                gCharacterEditorFolderCardFrmId = traitGetFrmId(gCharacterEditorTempTraits[1]);
                gCharacterEditorFolderCardTitle = traitGetName(gCharacterEditorTempTraits[1]);
                gCharacterEditorFolderCardSubtitle = NULL;
                gCharacterEditorFolderCardDescription = traitGetDescription(gCharacterEditorTempTraits[1]);
                hasContent = true;
            }
        }
    }

    for (perk = 0; perk < PERK_COUNT; perk++) {
        if (perkGetRank(gDude, perk) != 0) {
            break;
        }
    }

    if (perk != PERK_COUNT) {
        // PERKS
        string = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 109);
        characterEditorFolderViewDrawHeading(string);

        for (perk = 0; perk < PERK_COUNT; perk++) {
            perkLevel = perkGetRank(gDude, perk);
            if (perkLevel != 0) {
                string = perkGetName(perk);

                if (perkLevel == 1) {
                    strcpy(perkName, string);
                } else {
                    sprintf(perkName, "%s (%d)", string, perkLevel);
                }

                if (characterEditorFolderViewDrawString(perkName)) {
                    gCharacterEditorFolderCardFrmId = perkGetFrmId(perk);
                    gCharacterEditorFolderCardTitle = perkGetName(perk);
                    gCharacterEditorFolderCardSubtitle = NULL;
                    gCharacterEditorFolderCardDescription = perkGetDescription(perk);
                    hasContent = true;
                }
            }
        }
    }

    if (!hasContent) {
        gCharacterEditorFolderCardFrmId = 71;
        // Perks
        gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 124);
        gCharacterEditorFolderCardSubtitle = NULL;
        // Perks add additional abilities. Every third experience level, you can choose one perk.
        gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 127);
    }
}

// 0x434498
static int characterEditorKillsCompare(const void* a1, const void* a2)
{
    const KillInfo* v1 = (const KillInfo*)a1;
    const KillInfo* v2 = (const KillInfo*)a2;
    return compat_stricmp(v1->name, v2->name);
}

// 0x4344A4
static int characterEditorDrawKillsFolder()
{
    int i;
    int killsCount;
    KillInfo kills[19];
    int usedKills = 0;
    bool hasContent = false;

    characterEditorFolderViewClear();

    for (i = 0; i < KILL_TYPE_COUNT; i++) {
        killsCount = killsGetByType(i);
        if (killsCount != 0) {
            KillInfo* killInfo = &(kills[usedKills]);
            killInfo->name = killTypeGetName(i);
            killInfo->killTypeId = i;
            killInfo->kills = killsCount;
            usedKills++;
        }
    }

    if (usedKills != 0) {
        qsort(kills, usedKills, sizeof(*kills), characterEditorKillsCompare);

        for (i = 0; i < usedKills; i++) {
            KillInfo* killInfo = &(kills[i]);
            if (characterEditorFolderViewDrawKillsEntry(killInfo->name, killInfo->kills)) {
                gCharacterEditorFolderCardFrmId = 46;
                gCharacterEditorFolderCardTitle = gCharacterEditorFolderCardString;
                gCharacterEditorFolderCardSubtitle = NULL;
                gCharacterEditorFolderCardDescription = killTypeGetDescription(kills[i].killTypeId);
                sprintf(gCharacterEditorFolderCardString, "%s %s", killInfo->name, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 126));
                hasContent = true;
            }
        }
    }

    if (!hasContent) {
        gCharacterEditorFolderCardFrmId = 46;
        gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 126);
        gCharacterEditorFolderCardSubtitle = NULL;
        gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 129);
    }

    return usedKills;
}

// 0x4345DC
static void characterEditorDrawBigNumber(int x, int y, int flags, int value, int previousValue, int windowHandle)
{
    Rect rect;
    int windowWidth;
    unsigned char* windowBuf;
    int tens;
    int ones;
    unsigned char* tensBufferPtr;
    unsigned char* onesBufferPtr;
    unsigned char* numbersGraphicBufferPtr;

    windowWidth = windowGetWidth(windowHandle);
    windowBuf = windowGetBuffer(windowHandle);

    rect.left = x;
    rect.top = y;
    rect.right = x + BIG_NUM_WIDTH * 2;
    rect.bottom = y + BIG_NUM_HEIGHT;

    numbersGraphicBufferPtr = gCharacterEditorFrmData[0];

    if (flags & RED_NUMBERS) {
        // First half of the bignum.frm is white,
        // second half is red.
        numbersGraphicBufferPtr += gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width / 2;
    }

    tensBufferPtr = windowBuf + windowWidth * y + x;
    onesBufferPtr = tensBufferPtr + BIG_NUM_WIDTH;

    if (value >= 0 && value <= 99 && previousValue >= 0 && previousValue <= 99) {
        tens = value / 10;
        ones = value % 10;

        if (flags & ANIMATE) {
            if (previousValue % 10 != ones) {
                _frame_time = _get_time();
                blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * 11,
                    BIG_NUM_WIDTH,
                    BIG_NUM_HEIGHT,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                    onesBufferPtr,
                    windowWidth);
                windowRefreshRect(windowHandle, &rect);
                while (getTicksSince(_frame_time) < BIG_NUM_ANIMATION_DELAY)
                    ;
            }

            blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * ones,
                BIG_NUM_WIDTH,
                BIG_NUM_HEIGHT,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                onesBufferPtr,
                windowWidth);
            windowRefreshRect(windowHandle, &rect);

            if (previousValue / 10 != tens) {
                _frame_time = _get_time();
                blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * 11,
                    BIG_NUM_WIDTH,
                    BIG_NUM_HEIGHT,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                    tensBufferPtr,
                    windowWidth);
                windowRefreshRect(windowHandle, &rect);
                while (getTicksSince(_frame_time) < BIG_NUM_ANIMATION_DELAY)
                    ;
            }

            blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * tens,
                BIG_NUM_WIDTH,
                BIG_NUM_HEIGHT,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                tensBufferPtr,
                windowWidth);
            windowRefreshRect(windowHandle, &rect);
        } else {
            blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * tens,
                BIG_NUM_WIDTH,
                BIG_NUM_HEIGHT,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                tensBufferPtr,
                windowWidth);
            blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * ones,
                BIG_NUM_WIDTH,
                BIG_NUM_HEIGHT,
                gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
                onesBufferPtr,
                windowWidth);
        }
    } else {

        blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * 9,
            BIG_NUM_WIDTH,
            BIG_NUM_HEIGHT,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
            tensBufferPtr,
            windowWidth);
        blitBufferToBuffer(numbersGraphicBufferPtr + BIG_NUM_WIDTH * 9,
            BIG_NUM_WIDTH,
            BIG_NUM_HEIGHT,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_BIG_NUMBERS].width,
            onesBufferPtr,
            windowWidth);
    }
}

// 0x434920
static void characterEditorDrawPcStats()
{
    int color;
    int y;
    char* formattedValue;
    // NOTE: The length of this buffer is 8 bytes, which is enough to display
    // 999,999 (7 bytes NULL-terminated) experience points. Usually a player
    // will never gain that much during normal gameplay.
    //
    // However it's possible to use one of the F2 modding tools and savegame
    // editors to receive rediculous amount of experience points. Vanilla is
    // able to handle it, because `stringBuffer` acts as continuation of
    // `formattedValueBuffer`. This is not the case with MSVC, where
    // insufficient space for xp greater then 999,999 ruins the stack. In order
    // to fix the `formattedValueBuffer` is expanded to 16 bytes, so it should
    // be possible to store max 32-bit integer (4,294,967,295).
    char formattedValueBuffer[16];
    char stringBuffer[128];

    if (gCharacterEditorIsCreationMode == 1) {
        return;
    }

    fontSetCurrent(101);

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + 640 * 280 + 32, 124, 32, 640, gCharacterEditorWindowBuffer + 640 * 280 + 32, 640);

    // LEVEL
    y = 280;
    if (characterEditorSelectedItem != 7) {
        color = _colorTable[992];
    } else {
        color = _colorTable[32747];
    }

    int level = pcGetStat(PC_STAT_LEVEL);
    sprintf(stringBuffer, "%s %d",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 113),
        level);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 32, stringBuffer, 640, 640, color);

    // EXPERIENCE
    y += fontGetLineHeight() + 1;
    if (characterEditorSelectedItem != 8) {
        color = _colorTable[992];
    } else {
        color = _colorTable[32747];
    }

    int exp = pcGetStat(PC_STAT_EXPERIENCE);
    sprintf(stringBuffer, "%s %s",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 114),
        _itostndn(exp, formattedValueBuffer));
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 32, stringBuffer, 640, 640, color);

    // EXP NEEDED TO NEXT LEVEL
    y += fontGetLineHeight() + 1;
    if (characterEditorSelectedItem != 9) {
        color = _colorTable[992];
    } else {
        color = _colorTable[32747];
    }

    int expToNextLevel = pcGetExperienceForNextLevel();
    int expMsgId;
    if (expToNextLevel == -1) {
        expMsgId = 115;
        formattedValue = byte_5016E4;
    } else {
        expMsgId = 115;
        if (expToNextLevel > 999999) {
            expMsgId = 175;
        }
        formattedValue = _itostndn(expToNextLevel, formattedValueBuffer);
    }

    sprintf(stringBuffer, "%s %s",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, expMsgId),
        formattedValue);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 32, stringBuffer, 640, 640, color);
}

// 0x434B38
static void characterEditorDrawPrimaryStat(int stat, bool animate, int previousValue)
{
    int off;
    int color;
    const char* description;
    int value;
    int flags;
    int messageListItemId;

    fontSetCurrent(101);

    if (stat == RENDER_ALL_STATS) {
        // NOTE: Original code is different, looks like tail recursion
        // optimization.
        for (stat = 0; stat < 7; stat++) {
            characterEditorDrawPrimaryStat(stat, 0, 0);
        }
        return;
    }

    if (characterEditorSelectedItem == stat) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    off = 640 * (gCharacterEditorPrimaryStatY[stat] + 8) + 103;

    // TODO: The original code is different.
    if (gCharacterEditorIsCreationMode) {
        value = critterGetBaseStatWithTraitModifier(gDude, stat) + critterGetBonusStat(gDude, stat);

        flags = 0;

        if (animate) {
            flags |= ANIMATE;
        }

        if (value > 10) {
            flags |= RED_NUMBERS;
        }

        characterEditorDrawBigNumber(58, gCharacterEditorPrimaryStatY[stat], flags, value, previousValue, gCharacterEditorWindow);

        blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + off, 40, fontGetLineHeight(), 640, gCharacterEditorWindowBuffer + off, 640);

        messageListItemId = critterGetStat(gDude, stat) + 199;
        if (messageListItemId > 210) {
            messageListItemId = 210;
        }

        description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, messageListItemId);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * (gCharacterEditorPrimaryStatY[stat] + 8) + 103, description, 640, 640, color);
    } else {
        value = critterGetStat(gDude, stat);
        characterEditorDrawBigNumber(58, gCharacterEditorPrimaryStatY[stat], 0, value, 0, gCharacterEditorWindow);
        blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + off, 40, fontGetLineHeight(), 640, gCharacterEditorWindowBuffer + off, 640);

        value = critterGetStat(gDude, stat);
        if (value > 10) {
            value = 10;
        }

        description = statGetValueDescription(value);
        fontDrawText(gCharacterEditorWindowBuffer + off, description, 640, 640, color);
    }
}

// 0x434F18
static void characterEditorDrawGender()
{
    int gender;
    char* str;
    char text[32];
    int x, width;

    fontSetCurrent(103);

    gender = critterGetStat(gDude, STAT_GENDER);
    str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 107 + gender);

    strcpy(text, str);

    width = gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].width;
    x = (width / 2) - (fontGetStringWidth(text) / 2);

    memcpy(gCharacterEditorFrmCopy[11],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_SEX_ON],
        width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_ON].height);
    memcpy(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_OFF],
        gCharacterEditorFrmData[10],
        width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_SEX_OFF].height);

    x += 6 * width;
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_ON] + x, text, width, width, _colorTable[14723]);
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_SEX_OFF] + x, text, width, width, _colorTable[18979]);
}

// 0x43501C
static void characterEditorDrawAge()
{
    int age;
    char* str;
    char text[32];
    int x, width;

    fontSetCurrent(103);

    age = critterGetStat(gDude, STAT_AGE);
    str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 104);

    sprintf(text, "%s %d", str, age);

    width = gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width;
    x = (width / 2) + 1 - (fontGetStringWidth(text) / 2);

    memcpy(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_ON],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_AGE_ON],
        width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].height);
    memcpy(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_AGE_OFF],
        width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].height);

    x += 6 * width;
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_ON] + x, text, width, width, _colorTable[14723]);
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_AGE_OFF] + x, text, width, width, _colorTable[18979]);
}

// 0x435118
static void characterEditorDrawName()
{
    char* str;
    char text[32];
    int x, width;
    char *pch, tmp;
    bool has_space;

    fontSetCurrent(103);

    str = critterGetName(gDude);
    strcpy(text, str);

    if (fontGetStringWidth(text) > 100) {
        pch = text;
        has_space = false;
        while (*pch != '\0') {
            tmp = *pch;
            *pch = '\0';
            if (tmp == ' ') {
                has_space = true;
            }

            if (fontGetStringWidth(text) > 100) {
                break;
            }

            *pch = tmp;
            pch++;
        }

        if (has_space) {
            pch = text + strlen(text);
            while (pch != text && *pch != ' ') {
                *pch = '\0';
                pch--;
            }
        }
    }

    width = gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width;
    x = (width / 2) + 3 - (fontGetStringWidth(text) / 2);

    memcpy(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_ON],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_NAME_ON],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].height);
    memcpy(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_NAME_OFF],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_OFF].width * gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_OFF].height);

    x += 6 * width;
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_ON] + x, text, width, width, _colorTable[14723]);
    fontDrawText(gCharacterEditorFrmCopy[EDITOR_GRAPHIC_NAME_OFF] + x, text, width, width, _colorTable[18979]);
}

// 0x43527C
static void characterEditorDrawDerivedStats()
{
    int conditions;
    int color;
    const char* messageListItemText;
    char t[420]; // TODO: Size is wrong.
    int y;

    conditions = gDude->data.critter.combat.results;

    fontSetCurrent(101);

    y = 46;

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + 640 * y + 194, 118, 108, 640, gCharacterEditorWindowBuffer + 640 * y + 194, 640);

    // Hit Points
    if (characterEditorSelectedItem == EDITOR_HIT_POINTS) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    int currHp;
    int maxHp;
    if (gCharacterEditorIsCreationMode) {
        maxHp = critterGetStat(gDude, STAT_MAXIMUM_HIT_POINTS);
        currHp = maxHp;
    } else {
        maxHp = critterGetStat(gDude, STAT_MAXIMUM_HIT_POINTS);
        currHp = critterGetHitPoints(gDude);
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 300);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    sprintf(t, "%d/%d", currHp, maxHp);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 263, t, 640, 640, color);

    // Poisoned
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_POISONED) {
        color = critterGetPoison(gDude) != 0 ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = critterGetPoison(gDude) != 0 ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 312);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Radiated
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_RADIATED) {
        color = critterGetRadiation(gDude) != 0 ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = critterGetRadiation(gDude) != 0 ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 313);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Eye Damage
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_EYE_DAMAGE) {
        color = (conditions & DAM_BLIND) ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = (conditions & DAM_BLIND) ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 314);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Crippled Right Arm
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_CRIPPLED_RIGHT_ARM) {
        color = (conditions & DAM_CRIP_ARM_RIGHT) ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = (conditions & DAM_CRIP_ARM_RIGHT) ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 315);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Crippled Left Arm
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_CRIPPLED_LEFT_ARM) {
        color = (conditions & DAM_CRIP_ARM_LEFT) ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = (conditions & DAM_CRIP_ARM_LEFT) ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 316);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Crippled Right Leg
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_CRIPPLED_RIGHT_LEG) {
        color = (conditions & DAM_CRIP_LEG_RIGHT) ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = (conditions & DAM_CRIP_LEG_RIGHT) ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 317);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    // Crippled Left Leg
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_CRIPPLED_LEFT_LEG) {
        color = (conditions & DAM_CRIP_LEG_LEFT) ? _colorTable[32747] : _colorTable[15845];
    } else {
        color = (conditions & DAM_CRIP_LEG_LEFT) ? _colorTable[992] : _colorTable[1313];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 318);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    y = 179;

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + 640 * y + 194, 116, 130, 640, gCharacterEditorWindowBuffer + 640 * y + 194, 640);

    // Armor Class
    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_ARMOR_CLASS) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 302);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_ARMOR_CLASS), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Action Points
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_ACTION_POINTS) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 301);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_MAXIMUM_ACTION_POINTS), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Carry Weight
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_CARRY_WEIGHT) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 311);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_CARRY_WEIGHT), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, critterIsEncumbered(gDude) ? _colorTable[31744] : color);

    // Melee Damage
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_MELEE_DAMAGE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 304);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_MELEE_DAMAGE), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Damage Resistance
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_DAMAGE_RESISTANCE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 305);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    sprintf(t, "%d%%", critterGetStat(gDude, STAT_DAMAGE_RESISTANCE));
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Poison Resistance
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_POISON_RESISTANCE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 306);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    sprintf(t, "%d%%", critterGetStat(gDude, STAT_POISON_RESISTANCE));
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Radiation Resistance
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_RADIATION_RESISTANCE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 307);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    sprintf(t, "%d%%", critterGetStat(gDude, STAT_RADIATION_RESISTANCE));
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Sequence
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_SEQUENCE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 308);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_SEQUENCE), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Healing Rate
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_HEALING_RATE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 309);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    compat_itoa(critterGetStat(gDude, STAT_HEALING_RATE), t, 10);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);

    // Critical Chance
    y += fontGetLineHeight() + 3;

    if (characterEditorSelectedItem == EDITOR_FIRST_DERIVED_STAT + EDITOR_DERIVED_STAT_CRITICAL_CHANCE) {
        color = _colorTable[32747];
    } else {
        color = _colorTable[992];
    }

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 310);
    sprintf(t, "%s", messageListItemText);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 194, t, 640, 640, color);

    sprintf(t, "%d%%", critterGetStat(gDude, STAT_CRITICAL_CHANCE));
    fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 288, t, 640, 640, color);
}

// 0x436154
static void characterEditorDrawSkills(int a1)
{
    int selectedSkill = -1;
    const char* str;
    int i;
    int color;
    int y;
    int value;
    char valueString[12]; // TODO: Size might be wrong.

    if (characterEditorSelectedItem >= EDITOR_FIRST_SKILL && characterEditorSelectedItem < 79) {
        selectedSkill = characterEditorSelectedItem - EDITOR_FIRST_SKILL;
    }

    if (gCharacterEditorIsCreationMode == 0 && a1 == 0) {
        buttonDestroy(gCharacterEditorSliderPlusBtn);
        buttonDestroy(gCharacterEditorSliderMinusBtn);
        gCharacterEditorSliderMinusBtn = -1;
        gCharacterEditorSliderPlusBtn = -1;
    }

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + 370, 270, 252, 640, gCharacterEditorWindowBuffer + 370, 640);

    fontSetCurrent(103);

    // SKILLS
    str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 117);
    fontDrawText(gCharacterEditorWindowBuffer + 640 * 5 + 380, str, 640, 640, _colorTable[18979]);

    if (!gCharacterEditorIsCreationMode) {
        // SKILL POINTS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 112);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * 233 + 400, str, 640, 640, _colorTable[18979]);

        value = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);
        characterEditorDrawBigNumber(522, 228, 0, value, 0, gCharacterEditorWindow);
    } else {
        // TAG SKILLS
        str = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 138);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * 233 + 422, str, 640, 640, _colorTable[18979]);

        // TODO: Check.
        if (a1 == 2 && !gCharacterEditorIsSkillsFirstDraw) {
            characterEditorDrawBigNumber(522, 228, ANIMATE, gCharacterEditorTaggedSkillCount, gCharacterEditorOldTaggedSkillCount, gCharacterEditorWindow);
        } else {
            characterEditorDrawBigNumber(522, 228, 0, gCharacterEditorTaggedSkillCount, 0, gCharacterEditorWindow);
            gCharacterEditorIsSkillsFirstDraw = 0;
        }
    }

    skillsSetTagged(gCharacterEditorTempTaggedSkills, NUM_TAGGED_SKILLS);

    fontSetCurrent(101);

    y = 27;
    for (i = 0; i < SKILL_COUNT; i++) {
        if (i == selectedSkill) {
            if (i != gCharacterEditorTempTaggedSkills[0] && i != gCharacterEditorTempTaggedSkills[1] && i != gCharacterEditorTempTaggedSkills[2] && i != gCharacterEditorTempTaggedSkills[3]) {
                color = _colorTable[32747];
            } else {
                color = _colorTable[32767];
            }
        } else {
            if (i != gCharacterEditorTempTaggedSkills[0] && i != gCharacterEditorTempTaggedSkills[1] && i != gCharacterEditorTempTaggedSkills[2] && i != gCharacterEditorTempTaggedSkills[3]) {
                color = _colorTable[992];
            } else {
                color = _colorTable[21140];
            }
        }

        str = skillGetName(i);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 380, str, 640, 640, color);

        value = skillGetValue(gDude, i);
        sprintf(valueString, "%d%%", value);

        // TODO: Check text position.
        fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 573, valueString, 640, 640, color);

        y += fontGetLineHeight() + 1;
    }

    if (!gCharacterEditorIsCreationMode) {
        y = gCharacterEditorCurrentSkill * (fontGetLineHeight() + 1);
        gCharacterEditorSkillValueAdjustmentSliderY = y + 27;

        blitBufferToBufferTrans(
            gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER],
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER].width,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER].height,
            gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER].width,
            gCharacterEditorWindowBuffer + 640 * (y + 16) + 592,
            640);

        if (a1 == 0) {
            if (gCharacterEditorSliderPlusBtn == -1) {
                gCharacterEditorSliderPlusBtn = buttonCreate(
                    gCharacterEditorWindow,
                    614,
                    gCharacterEditorSkillValueAdjustmentSliderY - 7,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].width,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_PLUS_ON].height,
                    -1,
                    522,
                    521,
                    522,
                    gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_OFF],
                    gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_PLUS_ON],
                    NULL,
                    96);
                buttonSetCallbacks(gCharacterEditorSliderPlusBtn, _gsound_red_butt_press, NULL);
            }

            if (gCharacterEditorSliderMinusBtn == -1) {
                gCharacterEditorSliderMinusBtn = buttonCreate(
                    gCharacterEditorWindow,
                    614,
                    gCharacterEditorSkillValueAdjustmentSliderY + 4 - 12 + gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].height,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_ON].width,
                    gCharacterEditorFrmSize[EDITOR_GRAPHIC_SLIDER_MINUS_OFF].height,
                    -1,
                    524,
                    523,
                    524,
                    gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_OFF],
                    gCharacterEditorFrmData[EDITOR_GRAPHIC_SLIDER_MINUS_ON],
                    NULL,
                    96);
                buttonSetCallbacks(gCharacterEditorSliderMinusBtn, _gsound_red_butt_press, NULL);
            }
        }
    }
}

// 0x4365AC
static void characterEditorDrawCard()
{
    int graphicId;
    char* title;
    char* description;

    if (characterEditorSelectedItem < 0 || characterEditorSelectedItem >= 98) {
        return;
    }

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + (640 * 267) + 345, 277, 170, 640, gCharacterEditorWindowBuffer + (267 * 640) + 345, 640);

    if (characterEditorSelectedItem >= 0 && characterEditorSelectedItem < 7) {
        description = statGetDescription(characterEditorSelectedItem);
        title = statGetName(characterEditorSelectedItem);
        graphicId = statGetFrmId(characterEditorSelectedItem);
        characterEditorDrawCardWithOptions(graphicId, title, NULL, description);
    } else if (characterEditorSelectedItem >= 7 && characterEditorSelectedItem < 10) {
        if (gCharacterEditorIsCreationMode) {
            switch (characterEditorSelectedItem) {
            case 7:
                // Character Points
                description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 121);
                title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 120);
                characterEditorDrawCardWithOptions(7, title, NULL, description);
                break;
            }
        } else {
            switch (characterEditorSelectedItem) {
            case 7:
                description = pcStatGetDescription(PC_STAT_LEVEL);
                title = pcStatGetName(PC_STAT_LEVEL);
                characterEditorDrawCardWithOptions(7, title, NULL, description);
                break;
            case 8:
                description = pcStatGetDescription(PC_STAT_EXPERIENCE);
                title = pcStatGetName(PC_STAT_EXPERIENCE);
                characterEditorDrawCardWithOptions(8, title, NULL, description);
                break;
            case 9:
                // Next Level
                description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 123);
                title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 122);
                characterEditorDrawCardWithOptions(9, title, NULL, description);
                break;
            }
        }
    } else if ((characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43) || (characterEditorSelectedItem >= 82 && characterEditorSelectedItem < 98)) {
        characterEditorDrawCardWithOptions(gCharacterEditorFolderCardFrmId, gCharacterEditorFolderCardTitle, gCharacterEditorFolderCardSubtitle, gCharacterEditorFolderCardDescription);
    } else if (characterEditorSelectedItem >= 43 && characterEditorSelectedItem < 51) {
        switch (characterEditorSelectedItem) {
        case EDITOR_HIT_POINTS:
            description = statGetDescription(STAT_MAXIMUM_HIT_POINTS);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 300);
            graphicId = statGetFrmId(STAT_MAXIMUM_HIT_POINTS);
            characterEditorDrawCardWithOptions(graphicId, title, NULL, description);
            break;
        case EDITOR_POISONED:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 400);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 312);
            characterEditorDrawCardWithOptions(11, title, NULL, description);
            break;
        case EDITOR_RADIATED:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 401);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 313);
            characterEditorDrawCardWithOptions(12, title, NULL, description);
            break;
        case EDITOR_EYE_DAMAGE:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 402);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 314);
            characterEditorDrawCardWithOptions(13, title, NULL, description);
            break;
        case EDITOR_CRIPPLED_RIGHT_ARM:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 403);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 315);
            characterEditorDrawCardWithOptions(14, title, NULL, description);
            break;
        case EDITOR_CRIPPLED_LEFT_ARM:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 404);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 316);
            characterEditorDrawCardWithOptions(15, title, NULL, description);
            break;
        case EDITOR_CRIPPLED_RIGHT_LEG:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 405);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 317);
            characterEditorDrawCardWithOptions(16, title, NULL, description);
            break;
        case EDITOR_CRIPPLED_LEFT_LEG:
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 406);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 318);
            characterEditorDrawCardWithOptions(17, title, NULL, description);
            break;
        }
    } else if (characterEditorSelectedItem >= EDITOR_FIRST_DERIVED_STAT && characterEditorSelectedItem < 61) {
        int derivedStatIndex = characterEditorSelectedItem - 51;
        int stat = gCharacterEditorDerivedStatsMap[derivedStatIndex];
        description = statGetDescription(stat);
        title = statGetName(stat);
        graphicId = gCharacterEditorDerivedStatFrmIds[derivedStatIndex];
        characterEditorDrawCardWithOptions(graphicId, title, NULL, description);
    } else if (characterEditorSelectedItem >= EDITOR_FIRST_SKILL && characterEditorSelectedItem < 79) {
        int skill = characterEditorSelectedItem - 61;
        const char* attributesDescription = skillGetAttributes(skill);

        char formatted[150]; // TODO: Size is probably wrong.
        const char* base = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 137);
        int defaultValue = skillGetDefaultValue(skill);
        sprintf(formatted, "%s %d%% %s", base, defaultValue, attributesDescription);

        graphicId = skillGetFrmId(skill);
        title = skillGetName(skill);
        description = skillGetDescription(skill);
        characterEditorDrawCardWithOptions(graphicId, title, formatted, description);
    } else if (characterEditorSelectedItem >= 79 && characterEditorSelectedItem < 82) {
        switch (characterEditorSelectedItem) {
        case EDITOR_TAG_SKILL:
            if (gCharacterEditorIsCreationMode) {
                // Tag Skill
                description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 145);
                title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 144);
                characterEditorDrawCardWithOptions(27, title, NULL, description);
            } else {
                // Skill Points
                description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 131);
                title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 130);
                characterEditorDrawCardWithOptions(27, title, NULL, description);
            }
            break;
        case EDITOR_SKILLS:
            // Skills
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 151);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 150);
            characterEditorDrawCardWithOptions(27, title, NULL, description);
            break;
        case EDITOR_OPTIONAL_TRAITS:
            // Optional Traits
            description = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 147);
            title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 146);
            characterEditorDrawCardWithOptions(27, title, NULL, description);
            break;
        }
    }
}

// 0x436C4C
static int characterEditorEditName()
{
    char* text;

    int windowWidth = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width;
    int windowHeight = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].height;

    int nameWindowX = (screenGetWidth() - EDITOR_WINDOW_WIDTH) / 2 + 17;
    int nameWindowY = (screenGetHeight() - EDITOR_WINDOW_HEIGHT) / 2;
    int win = windowCreate(nameWindowX, nameWindowY, windowWidth, windowHeight, 256, WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);
    if (win == -1) {
        return -1;
    }

    unsigned char* windowBuf = windowGetBuffer(win);

    // Copy background
    memcpy(windowBuf, gCharacterEditorFrmData[EDITOR_GRAPHIC_CHARWIN], windowWidth * windowHeight);

    blitBufferToBufferTrans(
        gCharacterEditorFrmData[EDITOR_GRAPHIC_NAME_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].width,
        windowBuf + windowWidth * 13 + 13,
        windowWidth);
    blitBufferToBufferTrans(gCharacterEditorFrmData[EDITOR_GRAPHIC_DONE_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        windowBuf + windowWidth * 40 + 13,
        windowWidth);

    fontSetCurrent(103);

    text = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 100);
    fontDrawText(windowBuf + windowWidth * 44 + 50, text, windowWidth, windowWidth, _colorTable[18979]);

    int doneBtn = buttonCreate(win,
        26,
        44,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        500,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (doneBtn != -1) {
        buttonSetCallbacks(doneBtn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    windowRefresh(win);

    fontSetCurrent(101);

    char name[64];
    strcpy(name, critterGetName(gDude));

    if (strcmp(name, "None") == 0) {
        name[0] = '\0';
    }

    // NOTE: I don't understand the nameCopy, not sure what it is used for. It's
    // definitely there, but I just don' get it.
    char nameCopy[64];
    strcpy(nameCopy, name);

    if (_get_input_str(win, 500, nameCopy, 11, 23, 19, _colorTable[992], 100, 0) != -1) {
        if (nameCopy[0] != '\0') {
            dudeSetName(nameCopy);
            characterEditorDrawName();
            windowDestroy(win);
            return 0;
        }
    }

    // NOTE: original code is a bit different, the following chunk of code written two times.

    fontSetCurrent(101);
    blitBufferToBuffer(gCharacterEditorFrmData[EDITOR_GRAPHIC_NAME_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_BOX].width,
        windowBuf + gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width * 13 + 13,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width);

    _PrintName(windowBuf, gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width);

    strcpy(nameCopy, name);

    windowDestroy(win);

    return 0;
}

// 0x436F70
static void _PrintName(unsigned char* buf, int pitch)
{
    char str[64];
    char* v4;

    memcpy(str, byte_431D93, 64);

    fontSetCurrent(101);

    v4 = critterGetName(gDude);

    // TODO: Check.
    strcpy(str, v4);

    fontDrawText(buf + 19 * pitch + 21, str, pitch, pitch, _colorTable[992]);
}

// 0x436FEC
static int characterEditorEditAge()
{
    int win;
    unsigned char* windowBuf;
    int windowWidth;
    int windowHeight;
    const char* messageListItemText;
    int previousAge;
    int age;
    int doneBtn;
    int prevBtn;
    int nextBtn;
    int keyCode;
    int change;
    int flags;

    int savedAge = critterGetStat(gDude, STAT_AGE);

    windowWidth = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width;
    windowHeight = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].height;

    int ageWindowX = (screenGetWidth() - EDITOR_WINDOW_WIDTH) / 2 + gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width + 9;
    int ageWindowY = (screenGetHeight() - EDITOR_WINDOW_HEIGHT) / 2;
    win = windowCreate(ageWindowX, ageWindowY, windowWidth, windowHeight, 256, WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);
    if (win == -1) {
        return -1;
    }

    windowBuf = windowGetBuffer(win);

    memcpy(windowBuf, gCharacterEditorFrmData[EDITOR_GRAPHIC_CHARWIN], windowWidth * windowHeight);

    blitBufferToBufferTrans(
        gCharacterEditorFrmData[EDITOR_GRAPHIC_AGE_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_BOX].width,
        windowBuf + windowWidth * 7 + 8,
        windowWidth);
    blitBufferToBufferTrans(
        gCharacterEditorFrmData[EDITOR_GRAPHIC_DONE_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        windowBuf + windowWidth * 40 + 13,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width);

    fontSetCurrent(103);

    messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 100);
    fontDrawText(windowBuf + windowWidth * 44 + 50, messageListItemText, windowWidth, windowWidth, _colorTable[18979]);

    age = critterGetStat(gDude, STAT_AGE);
    characterEditorDrawBigNumber(55, 10, 0, age, 0, win);

    doneBtn = buttonCreate(win,
        26,
        44,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        500,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (doneBtn != -1) {
        buttonSetCallbacks(doneBtn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    nextBtn = buttonCreate(win,
        105,
        13,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LEFT_ARROW_DOWN].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LEFT_ARROW_DOWN].height,
        -1,
        503,
        501,
        503,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_RIGHT_ARROW_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_RIGHT_ARROW_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (nextBtn != -1) {
        buttonSetCallbacks(nextBtn, _gsound_med_butt_press, NULL);
    }

    prevBtn = buttonCreate(win,
        19,
        13,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_RIGHT_ARROW_DOWN].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_RIGHT_ARROW_DOWN].height,
        -1,
        504,
        502,
        504,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LEFT_ARROW_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LEFT_ARROW_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (prevBtn != -1) {
        buttonSetCallbacks(prevBtn, _gsound_med_butt_press, NULL);
    }

    while (true) {
        _frame_time = _get_time();
        change = 0;
        flags = 0;
        int v32 = 0;

        keyCode = _get_input();

        if (keyCode == KEY_RETURN || keyCode == 500) {
            if (keyCode != 500) {
                soundPlayFile("ib1p1xx1");
            }

            windowDestroy(win);
            return 0;
        } else if (keyCode == KEY_ESCAPE || _game_user_wants_to_quit != 0) {
            break;
        } else if (keyCode == 501) {
            age = critterGetStat(gDude, STAT_AGE);
            if (age < 35) {
                change = 1;
            }
        } else if (keyCode == 502) {
            age = critterGetStat(gDude, STAT_AGE);
            if (age > 16) {
                change = -1;
            }
        } else if (keyCode == KEY_PLUS || keyCode == KEY_UPPERCASE_N || keyCode == KEY_ARROW_UP) {
            previousAge = critterGetStat(gDude, STAT_AGE);
            if (previousAge < 35) {
                flags = ANIMATE;
                if (critterIncBaseStat(gDude, STAT_AGE) != 0) {
                    flags = 0;
                }
                age = critterGetStat(gDude, STAT_AGE);
                characterEditorDrawBigNumber(55, 10, flags, age, previousAge, win);
            }
        } else if (keyCode == KEY_MINUS || keyCode == KEY_UPPERCASE_J || keyCode == KEY_ARROW_DOWN) {
            previousAge = critterGetStat(gDude, STAT_AGE);
            if (previousAge > 16) {
                flags = ANIMATE;
                if (critterDecBaseStat(gDude, STAT_AGE) != 0) {
                    flags = 0;
                }
                age = critterGetStat(gDude, STAT_AGE);

                characterEditorDrawBigNumber(55, 10, flags, age, previousAge, win);
            }
        }

        if (flags == ANIMATE) {
            characterEditorDrawAge();
            characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
            characterEditorDrawDerivedStats();
            windowRefresh(gCharacterEditorWindow);
            windowRefresh(win);
        }

        if (change != 0) {
            int v33 = 0;

            _repFtime = 4;

            while (true) {
                _frame_time = _get_time();

                v33++;

                if ((!v32 && v33 == 1) || (v32 && v33 > dbl_50170B)) {
                    v32 = true;

                    if (v33 > dbl_50170B) {
                        _repFtime++;
                        if (_repFtime > 24) {
                            _repFtime = 24;
                        }
                    }

                    flags = ANIMATE;
                    previousAge = critterGetStat(gDude, STAT_AGE);

                    if (change == 1) {
                        if (previousAge < 35) {
                            if (critterIncBaseStat(gDude, STAT_AGE) != 0) {
                                flags = 0;
                            }
                        }
                    } else {
                        if (previousAge >= 16) {
                            if (critterDecBaseStat(gDude, STAT_AGE) != 0) {
                                flags = 0;
                            }
                        }
                    }

                    age = critterGetStat(gDude, STAT_AGE);
                    characterEditorDrawBigNumber(55, 10, flags, age, previousAge, win);
                    if (flags == ANIMATE) {
                        characterEditorDrawAge();
                        characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
                        characterEditorDrawDerivedStats();
                        windowRefresh(gCharacterEditorWindow);
                        windowRefresh(win);
                    }
                }

                if (v33 > dbl_50170B) {
                    while (getTicksSince(_frame_time) < 1000 / _repFtime)
                        ;
                } else {
                    while (getTicksSince(_frame_time) < 1000 / 24)
                        ;
                }

                keyCode = _get_input();
                if (keyCode == 503 || keyCode == 504 || _game_user_wants_to_quit != 0) {
                    break;
                }
            }
        } else {
            windowRefresh(win);

            while (getTicksSince(_frame_time) < 1000 / 24)
                ;
        }
    }

    critterSetBaseStat(gDude, STAT_AGE, savedAge);
    characterEditorDrawAge();
    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
    characterEditorDrawDerivedStats();
    windowRefresh(gCharacterEditorWindow);
    windowRefresh(win);
    windowDestroy(win);
    return 0;
}

// 0x437664
static void characterEditorEditGender()
{
    char* text;

    int windowWidth = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].width;
    int windowHeight = gCharacterEditorFrmSize[EDITOR_GRAPHIC_CHARWIN].height;

    int genderWindowX = (screenGetWidth() - EDITOR_WINDOW_WIDTH) / 2 + 9
        + gCharacterEditorFrmSize[EDITOR_GRAPHIC_NAME_ON].width
        + gCharacterEditorFrmSize[EDITOR_GRAPHIC_AGE_ON].width;
    int genderWindowY = (screenGetHeight() - EDITOR_WINDOW_HEIGHT) / 2;
    int win = windowCreate(genderWindowX, genderWindowY, windowWidth, windowHeight, 256, WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);

    if (win == -1) {
        return;
    }

    unsigned char* windowBuf = windowGetBuffer(win);

    // Copy background
    memcpy(windowBuf, gCharacterEditorFrmData[EDITOR_GRAPHIC_CHARWIN], windowWidth * windowHeight);

    blitBufferToBufferTrans(gCharacterEditorFrmData[EDITOR_GRAPHIC_DONE_BOX],
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_DONE_BOX].width,
        windowBuf + windowWidth * 44 + 15,
        windowWidth);

    fontSetCurrent(103);

    text = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 100);
    fontDrawText(windowBuf + windowWidth * 48 + 52, text, windowWidth, windowWidth, _colorTable[18979]);

    int doneBtn = buttonCreate(win,
        28,
        48,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        500,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (doneBtn != -1) {
        buttonSetCallbacks(doneBtn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    int btns[2];
    btns[0] = buttonCreate(win,
        22,
        2,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_MALE_ON].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_MALE_ON].height,
        -1,
        -1,
        501,
        -1,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_MALE_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_MALE_ON],
        NULL,
        BUTTON_FLAG_TRANSPARENT | BUTTON_FLAG_0x04 | BUTTON_FLAG_0x02 | BUTTON_FLAG_0x01);
    if (btns[0] != -1) {
        buttonSetCallbacks(doneBtn, _gsound_red_butt_press, NULL);
    }

    btns[1] = buttonCreate(win,
        71,
        3,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_FEMALE_ON].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_FEMALE_ON].height,
        -1,
        -1,
        502,
        -1,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_FEMALE_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_FEMALE_ON],
        NULL,
        BUTTON_FLAG_TRANSPARENT | BUTTON_FLAG_0x04 | BUTTON_FLAG_0x02 | BUTTON_FLAG_0x01);
    if (btns[1] != -1) {
        _win_group_radio_buttons(2, btns);
        buttonSetCallbacks(doneBtn, _gsound_red_butt_press, NULL);
    }

    int savedGender = critterGetStat(gDude, STAT_GENDER);
    _win_set_button_rest_state(btns[savedGender], 1, 0);

    while (true) {
        _frame_time = _get_time();

        int eventCode = _get_input();

        if (eventCode == KEY_RETURN || eventCode == 500) {
            if (eventCode == KEY_RETURN) {
                soundPlayFile("ib1p1xx1");
            }
            break;
        }

        if (eventCode == KEY_ESCAPE || _game_user_wants_to_quit != 0) {
            critterSetBaseStat(gDude, STAT_GENDER, savedGender);
            characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
            characterEditorDrawDerivedStats();
            windowRefresh(gCharacterEditorWindow);
            break;
        }

        switch (eventCode) {
        case KEY_ARROW_LEFT:
        case KEY_ARROW_RIGHT:
            if (1) {
                bool wasMale = _win_button_down(btns[0]);
                _win_set_button_rest_state(btns[0], !wasMale, 1);
                _win_set_button_rest_state(btns[1], wasMale, 1);
            }
            break;
        case 501:
        case 502:
            // TODO: Original code is slightly different.
            critterSetBaseStat(gDude, STAT_GENDER, eventCode - 501);
            characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
            characterEditorDrawDerivedStats();
            break;
        }

        windowRefresh(win);

        while (getTicksSince(_frame_time) < 41)
            ;
    }

    characterEditorDrawGender();
    windowDestroy(win);
}

// 0x4379BC
static void characterEditorAdjustPrimaryStat(int eventCode)
{
    _repFtime = 4;

    int savedRemainingCharacterPoints = gCharacterEditorRemainingCharacterPoints;

    if (!gCharacterEditorIsCreationMode) {
        return;
    }

    int incrementingStat = eventCode - 503;
    int decrementingStat = eventCode - 510;

    int v11 = 0;

    bool cont = true;
    do {
        _frame_time = _get_time();
        if (v11 <= 19.2) {
            v11++;
        }

        if (v11 == 1 || v11 > 19.2) {
            if (v11 > 19.2) {
                _repFtime++;
                if (_repFtime > 24) {
                    _repFtime = 24;
                }
            }

            if (eventCode >= 510) {
                int previousValue = critterGetStat(gDude, decrementingStat);
                if (critterDecBaseStat(gDude, decrementingStat) == 0) {
                    gCharacterEditorRemainingCharacterPoints++;
                } else {
                    cont = false;
                }

                characterEditorDrawPrimaryStat(decrementingStat, cont ? ANIMATE : 0, previousValue);
                characterEditorDrawBigNumber(126, 282, cont ? ANIMATE : 0, gCharacterEditorRemainingCharacterPoints, savedRemainingCharacterPoints, gCharacterEditorWindow);
                critterUpdateDerivedStats(gDude);
                characterEditorDrawDerivedStats();
                characterEditorDrawSkills(0);
                characterEditorSelectedItem = decrementingStat;
            } else {
                int previousValue = critterGetBaseStatWithTraitModifier(gDude, incrementingStat);
                previousValue += critterGetBonusStat(gDude, incrementingStat);
                if (gCharacterEditorRemainingCharacterPoints > 0 && previousValue < 10 && critterIncBaseStat(gDude, incrementingStat) == 0) {
                    gCharacterEditorRemainingCharacterPoints--;
                } else {
                    cont = false;
                }

                characterEditorDrawPrimaryStat(incrementingStat, cont ? ANIMATE : 0, previousValue);
                characterEditorDrawBigNumber(126, 282, cont ? ANIMATE : 0, gCharacterEditorRemainingCharacterPoints, savedRemainingCharacterPoints, gCharacterEditorWindow);
                critterUpdateDerivedStats(gDude);
                characterEditorDrawDerivedStats();
                characterEditorDrawSkills(0);
                characterEditorSelectedItem = incrementingStat;
            }

            windowRefresh(gCharacterEditorWindow);
        }

        if (v11 >= 19.2) {
            unsigned int delay = 1000 / _repFtime;
            while (getTicksSince(_frame_time) < delay) {
            }
        } else {
            while (getTicksSince(_frame_time) < 1000 / 24) {
            }
        }
    } while (_get_input() != 518 && cont);

    characterEditorDrawCard();
}

// handle options dialog
//
// 0x437C08
static int characterEditorShowOptions()
{
    int width = gCharacterEditorFrmSize[43].width;
    int height = gCharacterEditorFrmSize[43].height;

    // NOTE: The following is a block of general purpose string buffers used in
    // this function. They are either store path, or strings from .msg files. I
    // don't know if such usage was intentional in the original code or it's a
    // result of some kind of compiler optimization.
    char string1[512];
    char string2[512];
    char string3[512];
    char string4[512];
    char string5[512];

    // Only two of the these blocks are used as a dialog body. Depending on the
    // dialog either 1 or 2 strings used from this array.
    const char* dialogBody[2] = {
        string5,
        string2,
    };

    if (gCharacterEditorIsCreationMode) {
        int optionsWindowX = (screenGetWidth() != 640)
            ? (screenGetWidth() - gCharacterEditorFrmSize[41].width) / 2
            : 238;
        int optionsWindowY = (screenGetHeight() != 480)
            ? (screenGetHeight() - gCharacterEditorFrmSize[41].height) / 2
            : 90;
        int win = windowCreate(optionsWindowX, optionsWindowY, gCharacterEditorFrmSize[41].width, gCharacterEditorFrmSize[41].height, 256, WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);
        if (win == -1) {
            return -1;
        }

        unsigned char* windowBuffer = windowGetBuffer(win);
        memcpy(windowBuffer, gCharacterEditorFrmData[41], gCharacterEditorFrmSize[41].width * gCharacterEditorFrmSize[41].height);

        fontSetCurrent(103);

        int err = 0;
        unsigned char* down[5];
        unsigned char* up[5];
        int size = width * height;
        int y = 17;
        int index;

        for (index = 0; index < 5; index++) {
            if (err != 0) {
                break;
            }

            do {
                down[index] = (unsigned char*)internal_malloc(size);
                if (down[index] == NULL) {
                    err = 1;
                    break;
                }

                up[index] = (unsigned char*)internal_malloc(size);
                if (up[index] == NULL) {
                    err = 2;
                    break;
                }

                memcpy(down[index], gCharacterEditorFrmData[43], size);
                memcpy(up[index], gCharacterEditorFrmData[42], size);

                strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 600 + index));

                int offset = width * 7 + width / 2 - fontGetStringWidth(string4) / 2;
                fontDrawText(up[index] + offset, string4, width, width, _colorTable[18979]);
                fontDrawText(down[index] + offset, string4, width, width, _colorTable[14723]);

                int btn = buttonCreate(win, 13, y, width, height, -1, -1, -1, 500 + index, up[index], down[index], NULL, BUTTON_FLAG_TRANSPARENT);
                if (btn != -1) {
                    buttonSetCallbacks(btn, _gsound_lrg_butt_press, NULL);
                }
            } while (0);

            y += height + 3;
        }

        if (err != 0) {
            if (err == 2) {
                internal_free(down[index]);
            }

            while (--index >= 0) {
                internal_free(up[index]);
                internal_free(down[index]);
            }

            return -1;
        }

        fontSetCurrent(101);

        int rc = 0;
        while (rc == 0) {
            int keyCode = _get_input();

            if (_game_user_wants_to_quit != 0) {
                rc = 2;
            } else if (keyCode == 504) {
                rc = 2;
            } else if (keyCode == KEY_RETURN || keyCode == KEY_UPPERCASE_D || keyCode == KEY_LOWERCASE_D) {
                // DONE
                rc = 2;
                soundPlayFile("ib1p1xx1");
            } else if (keyCode == KEY_ESCAPE) {
                rc = 2;
            } else if (keyCode == 503 || keyCode == KEY_UPPERCASE_E || keyCode == KEY_LOWERCASE_E) {
                // ERASE
                strcpy(string5, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 605));
                strcpy(string2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 606));

                if (showDialogBox(NULL, dialogBody, 2, 169, 126, _colorTable[992], NULL, _colorTable[992], DIALOG_BOX_YES_NO) != 0) {
                    _ResetPlayer();
                    skillsGetTagged(gCharacterEditorTempTaggedSkills, NUM_TAGGED_SKILLS);

                    int taggedSkillCount = 0;
                    for (int index = 3; index >= 0; index--) {
                        if (gCharacterEditorTempTaggedSkills[index] != -1) {
                            break;
                        }
                        taggedSkillCount++;
                    }

                    if (gCharacterEditorIsCreationMode) {
                        taggedSkillCount--;
                    }

                    gCharacterEditorTaggedSkillCount = taggedSkillCount;

                    traitsGetSelected(&gCharacterEditorTempTraits[0], &gCharacterEditorTempTraits[1]);

                    int traitCount = 0;
                    for (int index = 1; index >= 0; index--) {
                        if (gCharacterEditorTempTraits[index] != -1) {
                            break;
                        }
                        traitCount++;
                    }

                    gCharacterEditorTempTraitCount = traitCount;
                    critterUpdateDerivedStats(gDude);
                    characterEditorResetScreen();
                }
            } else if (keyCode == 502 || keyCode == KEY_UPPERCASE_P || keyCode == KEY_LOWERCASE_P) {
                // PRINT TO FILE
                string4[0] = '\0';

                strcat(string4, "*.");
                strcat(string4, "TXT");

                char** fileList;
                int fileListLength = fileNameListInit(string4, &fileList, 0, 0);
                if (fileListLength != -1) {
                    // PRINT
                    strcpy(string1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 616));

                    // PRINT TO FILE
                    strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 602));

                    if (showSaveFileDialog(string4, fileList, string1, fileListLength, 168, 80, 0) == 0) {
                        strcat(string1, ".");
                        strcat(string1, "TXT");

                        string4[0] = '\0';
                        strcat(string4, string1);

                        if (!characterFileExists(string4)) {
                            // already exists
                            sprintf(string4,
                                "%s %s",
                                compat_strupr(string1),
                                getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 609));

                            strcpy(string5, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 610));

                            if (showDialogBox(string4, dialogBody, 1, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0x10) != 0) {
                                rc = 1;
                            } else {
                                rc = 0;
                            }
                        } else {
                            rc = 1;
                        }

                        if (rc != 0) {
                            string4[0] = '\0';
                            strcat(string4, string1);

                            if (characterPrintToFile(string4) == 0) {
                                sprintf(string4,
                                    "%s%s",
                                    compat_strupr(string1),
                                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 607));
                                showDialogBox(string4, NULL, 0, 169, 126, _colorTable[992], NULL, _colorTable[992], 0);
                            } else {
                                soundPlayFile("iisxxxx1");

                                sprintf(string4,
                                    "%s%s%s",
                                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 611),
                                    compat_strupr(string1),
                                    "!");
                                showDialogBox(string4, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[992], 0x01);
                            }
                        }
                    }

                    fileNameListFree(&fileList, 0);
                } else {
                    soundPlayFile("iisxxxx1");

                    strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 615));
                    showDialogBox(string4, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0);

                    rc = 0;
                }
            } else if (keyCode == 501 || keyCode == KEY_UPPERCASE_L || keyCode == KEY_LOWERCASE_L) {
                // LOAD
                string4[0] = '\0';
                strcat(string4, "*.");
                strcat(string4, "GCD");

                char** fileNameList;
                int fileNameListLength = fileNameListInit(string4, &fileNameList, 0, 0);
                if (fileNameListLength != -1) {
                    // NOTE: This value is not copied as in save dialog.
                    char* title = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 601);
                    int loadFileDialogRc = showLoadFileDialog(title, fileNameList, string3, fileNameListLength, 168, 80, 0);
                    if (loadFileDialogRc == -1) {
                        fileNameListFree(&fileNameList, 0);
                        // FIXME: This branch ignores cleanup at the end of the loop.
                        return -1;
                    }

                    if (loadFileDialogRc == 0) {
                        string4[0] = '\0';
                        strcat(string4, string3);

                        int oldRemainingCharacterPoints = gCharacterEditorRemainingCharacterPoints;

                        _ResetPlayer();

                        if (gcdLoad(string4) == 0) {
                            critterUpdateDerivedStats(gDude);
                            pcStatsReset();
                            for (int stat = 0; stat < SAVEABLE_STAT_COUNT; stat++) {
                                critterSetBonusStat(gDude, stat, 0);
                            }
                            perksReset();
                            critterUpdateDerivedStats(gDude);
                            skillsGetTagged(gCharacterEditorTempTaggedSkills, 4);

                            int taggedSkillCount = 0;
                            for (int index = 3; index >= 0; index--) {
                                if (gCharacterEditorTempTaggedSkills[index] != -1) {
                                    break;
                                }
                                taggedSkillCount++;
                            }

                            if (gCharacterEditorIsCreationMode) {
                                taggedSkillCount--;
                            }

                            gCharacterEditorTaggedSkillCount = taggedSkillCount;

                            traitsGetSelected(&(gCharacterEditorTempTraits[0]), &(gCharacterEditorTempTraits[1]));

                            int traitCount = 0;
                            for (int index = 1; index >= 0; index--) {
                                if (gCharacterEditorTempTraits[index] != -1) {
                                    break;
                                }
                                traitCount++;
                            }

                            gCharacterEditorTempTraitCount = traitCount;

                            critterUpdateDerivedStats(gDude);

                            critterAdjustHitPoints(gDude, 1000);

                            rc = 1;
                        } else {
                            characterEditorRestorePlayer();
                            gCharacterEditorRemainingCharacterPoints = oldRemainingCharacterPoints;
                            critterAdjustHitPoints(gDude, 1000);
                            soundPlayFile("iisxxxx1");

                            strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 612));
                            strcat(string4, string3);
                            strcat(string4, "!");

                            showDialogBox(string4, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0);
                        }

                        characterEditorResetScreen();
                    }

                    fileNameListFree(&fileNameList, 0);
                } else {
                    soundPlayFile("iisxxxx1");

                    // Error reading file list!
                    strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 615));
                    rc = 0;

                    showDialogBox(string4, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0);
                }
            } else if (keyCode == 500 || keyCode == KEY_UPPERCASE_S || keyCode == KEY_LOWERCASE_S) {
                // SAVE
                string4[0] = '\0';
                strcat(string4, "*.");
                strcat(string4, "GCD");

                char** fileNameList;
                int fileNameListLength = fileNameListInit(string4, &fileNameList, 0, 0);
                if (fileNameListLength != -1) {
                    strcpy(string1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 617));
                    strcpy(string4, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 600));

                    if (showSaveFileDialog(string4, fileNameList, string1, fileNameListLength, 168, 80, 0) == 0) {
                        strcat(string1, ".");
                        strcat(string1, "GCD");

                        string4[0] = '\0';
                        strcat(string4, string1);

                        bool shouldSave;
                        if (characterFileExists(string4)) {
                            sprintf(string4, "%s %s",
                                compat_strupr(string1),
                                getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 609));
                            strcpy(string5, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 610));

                            if (showDialogBox(string4, dialogBody, 1, 169, 126, _colorTable[32328], NULL, _colorTable[32328], DIALOG_BOX_YES_NO) != 0) {
                                shouldSave = true;
                            } else {
                                shouldSave = false;
                            }
                        } else {
                            shouldSave = true;
                        }

                        if (shouldSave) {
                            skillsSetTagged(gCharacterEditorTempTaggedSkills, 4);
                            traitsSetSelected(gCharacterEditorTempTraits[0], gCharacterEditorTempTraits[1]);

                            string4[0] = '\0';
                            strcat(string4, string1);

                            if (gcdSave(string4) != 0) {
                                soundPlayFile("iisxxxx1");
                                sprintf(string4, "%s%s!",
                                    compat_strupr(string1),
                                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 611));
                                showDialogBox(string4, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], DIALOG_BOX_LARGE);
                                rc = 0;
                            } else {
                                sprintf(string4, "%s%s",
                                    compat_strupr(string1),
                                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 607));
                                showDialogBox(string4, NULL, 0, 169, 126, _colorTable[992], NULL, _colorTable[992], DIALOG_BOX_LARGE);
                                rc = 1;
                            }
                        }
                    }

                    fileNameListFree(&fileNameList, 0);
                } else {
                    soundPlayFile("iisxxxx1");

                    // Error reading file list!
                    char* msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 615);
                    showDialogBox(msg, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0);

                    rc = 0;
                }
            }

            windowRefresh(win);
        }

        windowDestroy(win);

        for (index = 0; index < 5; index++) {
            internal_free(up[index]);
            internal_free(down[index]);
        }

        return 0;
    }

    // Character Editor is not in creation mode - this button is only for
    // printing character details.

    char pattern[512];
    strcpy(pattern, "*.TXT");

    char** fileNames;
    int filesCount = fileNameListInit(pattern, &fileNames, 0, 0);
    if (filesCount == -1) {
        soundPlayFile("iisxxxx1");

        // Error reading file list!
        strcpy(pattern, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 615));
        showDialogBox(pattern, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0);
        return 0;
    }

    // PRINT
    char fileName[512];
    strcpy(fileName, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 616));

    char title[512];
    strcpy(title, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 602));

    if (showSaveFileDialog(title, fileNames, fileName, filesCount, 168, 80, 0) == 0) {
        strcat(fileName, ".TXT");

        title[0] = '\0';
        strcat(title, fileName);

        int v42 = 0;
        if (characterFileExists(title)) {
            sprintf(title,
                "%s %s",
                compat_strupr(fileName),
                getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 609));

            char line2[512];
            strcpy(line2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 610));

            const char* lines[] = { line2 };
            v42 = showDialogBox(title, lines, 1, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 0x10);
            if (v42) {
                v42 = 1;
            }
        } else {
            v42 = 1;
        }

        if (v42) {
            title[0] = '\0';
            strcpy(title, fileName);

            if (characterPrintToFile(title) != 0) {
                soundPlayFile("iisxxxx1");

                sprintf(title,
                    "%s%s%s",
                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 611),
                    compat_strupr(fileName),
                    "!");
                showDialogBox(title, NULL, 0, 169, 126, _colorTable[32328], NULL, _colorTable[32328], 1);
            }
        }
    }

    fileNameListFree(&fileNames, 0);

    return 0;
}

// 0x4390B4
static bool characterFileExists(const char* fname)
{
    File* stream = fileOpen(fname, "rb");
    if (stream == NULL) {
        return false;
    }

    fileClose(stream);
    return true;
}

// 0x4390D0
static int characterPrintToFile(const char* fileName)
{
    File* stream = fileOpen(fileName, "wt");
    if (stream == NULL) {
        return -1;
    }

    fileWriteString("\n", stream);
    fileWriteString("\n", stream);

    char title1[256];
    char title2[256];
    char title3[256];
    char padding[256];

    // FALLOUT
    strcpy(title1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 620));

    // NOTE: Uninline.
    padding[0] = '\0';
    _AddSpaces(padding, (80 - strlen(title1)) / 2 - 2);

    strcat(padding, title1);
    strcat(padding, "\n");
    fileWriteString(padding, stream);

    // VAULT-13 PERSONNEL RECORD
    strcpy(title1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 621));

    // NOTE: Uninline.
    padding[0] = '\0';
    _AddSpaces(padding, (80 - strlen(title1)) / 2 - 2);

    strcat(padding, title1);
    strcat(padding, "\n");
    fileWriteString(padding, stream);

    int month;
    int day;
    int year;
    gameTimeGetDate(&month, &day, &year);

    sprintf(title1, "%.2d %s %d  %.4d %s",
        day,
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 500 + month - 1),
        year,
        gameTimeGetHour(),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 622));

    // NOTE: Uninline.
    padding[0] = '\0';
    _AddSpaces(padding, (80 - strlen(title1)) / 2 - 2);

    strcat(padding, title1);
    strcat(padding, "\n");
    fileWriteString(padding, stream);

    // Blank line
    fileWriteString("\n", stream);

    // Name
    sprintf(title1,
        "%s %s",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 642),
        critterGetName(gDude));

    int paddingLength = 27 - strlen(title1);
    if (paddingLength > 0) {
        // NOTE: Uninline.
        padding[0] = '\0';
        _AddSpaces(padding, paddingLength);

        strcat(title1, padding);
    }

    // Age
    sprintf(title2,
        "%s%s %d",
        title1,
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 643),
        critterGetStat(gDude, STAT_AGE));

    // Gender
    sprintf(title3,
        "%s%s %s",
        title2,
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 644),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 645 + critterGetStat(gDude, STAT_GENDER)));

    fileWriteString(title3, stream);
    fileWriteString("\n", stream);

    sprintf(title1,
        "%s %.2d %s %s ",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 647),
        pcGetStat(PC_STAT_LEVEL),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 648),
        _itostndn(pcGetStat(PC_STAT_EXPERIENCE), title3));

    paddingLength = 12 - strlen(title3);
    if (paddingLength > 0) {
        // NOTE: Uninline.
        padding[0] = '\0';
        _AddSpaces(padding, paddingLength);

        strcat(title1, padding);
    }

    sprintf(title2,
        "%s%s %s",
        title1,
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 649),
        _itostndn(pcGetExperienceForNextLevel(), title3));
    fileWriteString(title2, stream);
    fileWriteString("\n", stream);
    fileWriteString("\n", stream);

    // Statistics
    sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 623));

    // Strength / Hit Points / Sequence
    //
    // FIXME: There is bug - it shows strength instead of sequence.
    sprintf(title1,
        "%s %.2d %s %.3d/%.3d %s %.2d",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 624),
        critterGetStat(gDude, STAT_STRENGTH),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 625),
        critterGetHitPoints(gDude),
        critterGetStat(gDude, STAT_MAXIMUM_HIT_POINTS),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 626),
        critterGetStat(gDude, STAT_STRENGTH));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Perception / Armor Class / Healing Rate
    sprintf(title1,
        "%s %.2d %s %.3d %s %.2d",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 627),
        critterGetStat(gDude, STAT_PERCEPTION),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 628),
        critterGetStat(gDude, STAT_ARMOR_CLASS),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 629),
        critterGetStat(gDude, STAT_HEALING_RATE));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Endurance / Action Points / Critical Chance
    sprintf(title1,
        "%s %.2d %s %.2d %s %.3d%%",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 630),
        critterGetStat(gDude, STAT_ENDURANCE),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 631),
        critterGetStat(gDude, STAT_MAXIMUM_ACTION_POINTS),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 632),
        critterGetStat(gDude, STAT_CRITICAL_CHANCE));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Charisma / Melee Damage / Carry Weight
    sprintf(title1,
        "%s %.2d %s %.2d %s %.3d lbs.",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 633),
        critterGetStat(gDude, STAT_CHARISMA),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 634),
        critterGetStat(gDude, STAT_MELEE_DAMAGE),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 635),
        critterGetStat(gDude, STAT_CARRY_WEIGHT));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Intelligence / Damage Resistance
    sprintf(title1,
        "%s %.2d %s %.3d%%",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 636),
        critterGetStat(gDude, STAT_INTELLIGENCE),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 637),
        critterGetStat(gDude, STAT_DAMAGE_RESISTANCE));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Agility / Radiation Resistance
    sprintf(title1,
        "%s %.2d %s %.3d%%",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 638),
        critterGetStat(gDude, STAT_AGILITY),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 639),
        critterGetStat(gDude, STAT_RADIATION_RESISTANCE));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    // Luck / Poison Resistance
    sprintf(title1,
        "%s %.2d %s %.3d%%",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 640),
        critterGetStat(gDude, STAT_LUCK),
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 641),
        critterGetStat(gDude, STAT_POISON_RESISTANCE));
    fileWriteString(title1, stream);
    fileWriteString("\n", stream);

    fileWriteString("\n", stream);
    fileWriteString("\n", stream);

    if (gCharacterEditorTempTraits[0] != -1) {
        // ::: Traits :::
        sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 650));
        fileWriteString(title1, stream);

        // NOTE: The original code does not use loop, or it was optimized away.
        for (int index = 0; index < TRAITS_MAX_SELECTED_COUNT; index++) {
            if (gCharacterEditorTempTraits[index] != -1) {
                sprintf(title1, "  %s", traitGetName(gCharacterEditorTempTraits[index]));
                fileWriteString(title1, stream);
                fileWriteString("\n", stream);
            }
        }
    }

    int perk = 0;
    for (; perk < PERK_COUNT; perk++) {
        if (perkGetRank(gDude, perk) != 0) {
            break;
        }
    }

    if (perk < PERK_COUNT) {
        // ::: Perks :::
        sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 651));
        fileWriteString(title1, stream);

        for (perk = 0; perk < PERK_COUNT; perk++) {
            int rank = perkGetRank(gDude, perk);
            if (rank != 0) {
                if (rank == 1) {
                    sprintf(title1, "  %s", perkGetName(perk));
                } else {
                    sprintf(title1, "  %s (%d)", perkGetName(perk), rank);
                }

                fileWriteString(title1, stream);
                fileWriteString("\n", stream);
            }
        }
    }

    fileWriteString("\n", stream);

    // ::: Karma :::
    sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 652));
    fileWriteString(title1, stream);

    for (int index = 0; index < gKarmaEntriesLength; index++) {
        KarmaEntry* karmaEntry = &(gKarmaEntries[index]);
        if (karmaEntry->gvar == GVAR_PLAYER_REPUTATION) {
            int reputation = 0;
            for (; reputation < gGenericReputationEntriesLength; reputation++) {
                GenericReputationEntry* reputationDescription = &(gGenericReputationEntries[reputation]);
                if (gGameGlobalVars[GVAR_PLAYER_REPUTATION] >= reputationDescription->threshold) {
                    break;
                }
            }

            if (reputation < gGenericReputationEntriesLength) {
                GenericReputationEntry* reputationDescription = &(gGenericReputationEntries[reputation]);
                sprintf(title1,
                    "  %s: %s (%s)",
                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 125),
                    compat_itoa(gGameGlobalVars[GVAR_PLAYER_REPUTATION], title2, 10),
                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, reputationDescription->name));
                fileWriteString(title1, stream);
                fileWriteString("\n", stream);
            }
        } else {
            if (gGameGlobalVars[karmaEntry->gvar] != 0) {
                sprintf(title1, "  %s", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, karmaEntry->name));
                fileWriteString(title1, stream);
                fileWriteString("\n", stream);
            }
        }
    }

    bool hasTownReputationHeading = false;
    for (int index = 0; index < TOWN_REPUTATION_COUNT; index++) {
        const TownReputationEntry* pair = &(gTownReputationEntries[index]);
        if (_wmAreaIsKnown(pair->city)) {
            if (!hasTownReputationHeading) {
                fileWriteString("\n", stream);

                // ::: Reputation :::
                sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 657));
                fileWriteString(title1, stream);
                hasTownReputationHeading = true;
            }

            _wmGetAreaIdxName(pair->city, title2);

            int townReputation = gGameGlobalVars[pair->gvar];

            int townReputationMessageId;

            if (townReputation < -30) {
                townReputationMessageId = 2006; // Vilified
            } else if (townReputation < -15) {
                townReputationMessageId = 2005; // Hated
            } else if (townReputation < 0) {
                townReputationMessageId = 2004; // Antipathy
            } else if (townReputation == 0) {
                townReputationMessageId = 2003; // Neutral
            } else if (townReputation < 15) {
                townReputationMessageId = 2002; // Accepted
            } else if (townReputation < 30) {
                townReputationMessageId = 2001; // Liked
            } else {
                townReputationMessageId = 2000; // Idolized
            }

            sprintf(title1,
                "  %s: %s",
                title2,
                getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, townReputationMessageId));
            fileWriteString(title1, stream);
            fileWriteString("\n", stream);
        }
    }

    bool hasAddictionsHeading = false;
    for (int index = 0; index < ADDICTION_REPUTATION_COUNT; index++) {
        if (gGameGlobalVars[gAddictionReputationVars[index]] != 0) {
            if (!hasAddictionsHeading) {
                fileWriteString("\n", stream);

                // ::: Addictions :::
                sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 656));
                fileWriteString(title1, stream);
                hasAddictionsHeading = true;
            }

            sprintf(title1,
                "  %s",
                getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 1004 + index));
            fileWriteString(title1, stream);
            fileWriteString("\n", stream);
        }
    }

    fileWriteString("\n", stream);

    // ::: Skills ::: / ::: Kills :::
    sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 653));
    fileWriteString(title1, stream);

    int killType = 0;
    for (int skill = 0; skill < SKILL_COUNT; skill++) {
        sprintf(title1, "%s ", skillGetName(skill));

        // NOTE: Uninline.
        _AddDots(title1 + strlen(title1), 16 - strlen(title1));

        bool hasKillType = false;

        for (; killType < KILL_TYPE_COUNT; killType++) {
            int killsCount = killsGetByType(killType);
            if (killsCount > 0) {
                sprintf(title2, "%s ", killTypeGetName(killType));

                // NOTE: Uninline.
                _AddDots(title2 + strlen(title2), 16 - strlen(title2));

                sprintf(title3,
                    "  %s %.3d%%        %s %.3d\n",
                    title1,
                    skillGetValue(gDude, skill),
                    title2,
                    killsCount);
                hasKillType = true;
                break;
            }
        }

        if (!hasKillType) {
            sprintf(title3,
                "  %s %.3d%%\n",
                title1,
                skillGetValue(gDude, skill));
        }
    }

    fileWriteString("\n", stream);
    fileWriteString("\n", stream);

    // ::: Inventory :::
    sprintf(title1, "%s\n", getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 654));
    fileWriteString(title1, stream);

    Inventory* inventory = &(gDude->data.inventory);
    for (int index = 0; index < inventory->length; index += 3) {
        title1[0] = '\0';

        for (int column = 0; column < 3; column++) {
            int inventoryItemIndex = index + column;
            if (inventoryItemIndex >= inventory->length) {
                break;
            }

            InventoryItem* inventoryItem = &(inventory->items[inventoryItemIndex]);

            sprintf(title2,
                "  %sx %s",
                _itostndn(inventoryItem->quantity, title3),
                objectGetName(inventoryItem->item));

            int length = 25 - strlen(title2);
            if (length < 0) {
                length = 0;
            }

            _AddSpaces(title2, length);

            strcat(title1, title2);
        }

        strcat(title1, "\n");
        fileWriteString(title1, stream);
    }

    fileWriteString("\n", stream);

    // Total Weight:
    sprintf(title1,
        "%s %d lbs.",
        getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 655),
        objectGetInventoryWeight(gDude));
    fileWriteString(title1, stream);

    fileWriteString("\n", stream);
    fileWriteString("\n", stream);
    fileWriteString("\n", stream);
    fileClose(stream);

    return 0;
}

// 0x43A55C
static char* _AddSpaces(char* string, int length)
{
    char* pch = string + strlen(string);

    for (int index = 0; index < length; index++) {
        *pch++ = ' ';
    }

    *pch = '\0';

    return string;
}

// NOTE: Inlined.
//
// 0x43A58C
static char* _AddDots(char* string, int length)
{
    char* pch = string + strlen(string);

    for (int index = 0; index < length; index++) {
        *pch++ = '.';
    }

    *pch = '\0';

    return string;
}

// 0x43A4BC
static void characterEditorResetScreen()
{
    characterEditorSelectedItem = 0;
    gCharacterEditorCurrentSkill = 0;
    gCharacterEditorSkillValueAdjustmentSliderY = 27;
    characterEditorWindowSelectedFolder = 0;

    if (gCharacterEditorIsCreationMode) {
        characterEditorDrawBigNumber(126, 282, 0, gCharacterEditorRemainingCharacterPoints, 0, gCharacterEditorWindow);
    } else {
        characterEditorDrawFolders();
        characterEditorDrawPcStats();
    }

    characterEditorDrawName();
    characterEditorDrawAge();
    characterEditorDrawGender();
    characterEditorDrawOptionalTraits();
    characterEditorDrawSkills(0);
    characterEditorDrawPrimaryStat(7, 0, 0);
    characterEditorDrawDerivedStats();
    characterEditorDrawCard();
    windowRefresh(gCharacterEditorWindow);
}

// 0x43A5BC
static void characterEditorRegisterInfoAreas()
{
    buttonCreate(gCharacterEditorWindow, 19, 38, 125, 227, -1, -1, 525, -1, NULL, NULL, NULL, 0);
    buttonCreate(gCharacterEditorWindow, 28, 280, 124, 32, -1, -1, 526, -1, NULL, NULL, NULL, 0);

    if (gCharacterEditorIsCreationMode) {
        buttonCreate(gCharacterEditorWindow, 52, 324, 169, 20, -1, -1, 533, -1, NULL, NULL, NULL, 0);
        buttonCreate(gCharacterEditorWindow, 47, 353, 245, 100, -1, -1, 534, -1, NULL, NULL, NULL, 0);
    } else {
        buttonCreate(gCharacterEditorWindow, 28, 363, 283, 105, -1, -1, 527, -1, NULL, NULL, NULL, 0);
    }

    buttonCreate(gCharacterEditorWindow, 191, 41, 122, 110, -1, -1, 528, -1, NULL, NULL, NULL, 0);
    buttonCreate(gCharacterEditorWindow, 191, 175, 122, 135, -1, -1, 529, -1, NULL, NULL, NULL, 0);
    buttonCreate(gCharacterEditorWindow, 376, 5, 223, 20, -1, -1, 530, -1, NULL, NULL, NULL, 0);
    buttonCreate(gCharacterEditorWindow, 370, 27, 223, 195, -1, -1, 531, -1, NULL, NULL, NULL, 0);
    buttonCreate(gCharacterEditorWindow, 396, 228, 171, 25, -1, -1, 532, -1, NULL, NULL, NULL, 0);
}

// copy character to editor
//
// 0x43A7DC
static void characterEditorSavePlayer()
{
    Proto* proto;
    protoGetProto(gDude->pid, &proto);
    critterProtoDataCopy(&gCharacterEditorDudeDataBackup, &(proto->critter.data));

    gCharacterEditorHitPointsBackup = critterGetHitPoints(gDude);

    strncpy(gCharacterEditorNameBackup, critterGetName(gDude), 32);

    gCharacterEditorLastLevelBackup = gCharacterEditorLastLevel;
    for (int perk = 0; perk < PERK_COUNT; perk++) {
        gCharacterEditorPerksBackup[perk] = perkGetRank(gDude, perk);
    }

    gCharacterEditorHasFreePerkBackup = gCharacterEditorHasFreePerk;

    gCharacterEditorUnspentSkillPointsBackup = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);

    skillsGetTagged(gCharacterEditorTaggedSkillsBackup, NUM_TAGGED_SKILLS);

    traitsGetSelected(&(gCharacterEditorOptionalTraitsBackup[0]), &(gCharacterEditorOptionalTraitsBackup[1]));

    for (int skill = 0; skill < SKILL_COUNT; skill++) {
        gCharacterEditorSkillsBackup[skill] = skillGetValue(gDude, skill);
    }
}

// copy editor to character
//
// 0x43A8BC
static void characterEditorRestorePlayer()
{
    Proto* proto;
    int i;
    int v3;
    int cur_hp;

    _pop_perks();

    protoGetProto(gDude->pid, &proto);
    critterProtoDataCopy(&(proto->critter.data), &gCharacterEditorDudeDataBackup);

    dudeSetName(gCharacterEditorNameBackup);

    gCharacterEditorLastLevel = gCharacterEditorLastLevelBackup;
    gCharacterEditorHasFreePerk = gCharacterEditorHasFreePerkBackup;

    pcSetStat(PC_STAT_UNSPENT_SKILL_POINTS, gCharacterEditorUnspentSkillPointsBackup);

    skillsSetTagged(gCharacterEditorTaggedSkillsBackup, NUM_TAGGED_SKILLS);

    traitsSetSelected(gCharacterEditorOptionalTraitsBackup[0], gCharacterEditorOptionalTraitsBackup[1]);

    skillsGetTagged(gCharacterEditorTempTaggedSkills, NUM_TAGGED_SKILLS);

    i = 4;
    v3 = 0;
    for (v3 = 0; v3 < 4; v3++) {
        if (gCharacterEditorTempTaggedSkills[--i] != -1) {
            break;
        }
    }

    if (gCharacterEditorIsCreationMode == 1) {
        v3 -= gCharacterEditorIsCreationMode;
    }

    gCharacterEditorTaggedSkillCount = v3;

    traitsGetSelected(&(gCharacterEditorTempTraits[0]), &(gCharacterEditorTempTraits[1]));

    i = 2;
    v3 = 0;
    for (v3 = 0; v3 < 2; v3++) {
        if (gCharacterEditorTempTraits[v3] != -1) {
            break;
        }
    }

    gCharacterEditorTempTraitCount = v3;

    critterUpdateDerivedStats(gDude);

    cur_hp = critterGetHitPoints(gDude);
    critterAdjustHitPoints(gDude, gCharacterEditorHitPointsBackup - cur_hp);
}

// 0x43A9CC
static char* _itostndn(int value, char* dest)
{
    int v16[7];
    memcpy(v16, dword_431DD4, sizeof(v16));

    char* savedDest = dest;

    if (value != 0) {
        *dest = '\0';

        bool v3 = false;
        for (int index = 0; index < 7; index++) {
            int v18 = value / v16[index];
            if (v18 > 0 || v3) {
                char temp[64]; // TODO: Size is probably wrong.
                compat_itoa(v18, temp, 10);
                strcat(dest, temp);

                v3 = true;

                value -= v16[index] * v18;

                if (index == 0 || index == 3) {
                    strcat(dest, ",");
                }
            }
        }
    } else {
        strcpy(dest, "0");
    }

    return savedDest;
}

// 0x43AAEC
static int characterEditorDrawCardWithOptions(int graphicId, const char* name, const char* attributes, char* description)
{
    CacheEntry* graphicHandle;
    Size size;
    int fid;
    unsigned char* buf;
    unsigned char* ptr;
    int v9;
    int x;
    int y;
    short beginnings[WORD_WRAP_MAX_COUNT];
    short beginningsCount;

    fid = buildFid(OBJ_TYPE_SKILLDEX, graphicId, 0, 0, 0);
    buf = artLockFrameDataReturningSize(fid, &graphicHandle, &(size.width), &(size.height));
    if (buf == NULL) {
        return -1;
    }

    blitBufferToBuffer(buf, size.width, size.height, size.width, gCharacterEditorWindowBuffer + 640 * 309 + 484, 640);

    v9 = 150;
    ptr = buf;
    for (y = 0; y < size.height; y++) {
        for (x = 0; x < size.width; x++) {
            if (_HighRGB_(*ptr) < 2 && v9 >= x) {
                v9 = x;
            }
            ptr++;
        }
    }

    v9 -= 8;
    if (v9 < 0) {
        v9 = 0;
    }

    fontSetCurrent(102);

    fontDrawText(gCharacterEditorWindowBuffer + 640 * 272 + 348, name, 640, 640, _colorTable[0]);
    int nameFontLineHeight = fontGetLineHeight();
    if (attributes != NULL) {
        int nameWidth = fontGetStringWidth(name);

        fontSetCurrent(101);
        int attributesFontLineHeight = fontGetLineHeight();
        fontDrawText(gCharacterEditorWindowBuffer + 640 * (268 + nameFontLineHeight - attributesFontLineHeight) + 348 + nameWidth + 8, attributes, 640, 640, _colorTable[0]);
    }

    y = nameFontLineHeight;
    windowDrawLine(gCharacterEditorWindow, 348, y + 272, 613, y + 272, _colorTable[0]);
    windowDrawLine(gCharacterEditorWindow, 348, y + 273, 613, y + 273, _colorTable[0]);

    fontSetCurrent(101);

    int descriptionFontLineHeight = fontGetLineHeight();

    if (wordWrap(description, v9 + 136, beginnings, &beginningsCount) != 0) {
        // TODO: Leaking graphic handle.
        return -1;
    }

    y = 315;
    for (short i = 0; i < beginningsCount - 1; i++) {
        short beginning = beginnings[i];
        short ending = beginnings[i + 1];
        char c = description[ending];
        description[ending] = '\0';
        fontDrawText(gCharacterEditorWindowBuffer + 640 * y + 348, description + beginning, 640, 640, _colorTable[0]);
        description[ending] = c;
        y += descriptionFontLineHeight;
    }

    if (graphicId != gCharacterEditorCardFrmId || strcmp(name, gCharacterEditorCardTitle) != 0) {
        if (gCharacterEditorCardDrawn) {
            soundPlayFile("isdxxxx1");
        }
    }

    strcpy(gCharacterEditorCardTitle, name);
    gCharacterEditorCardFrmId = graphicId;
    gCharacterEditorCardDrawn = true;

    artUnlock(graphicHandle);

    return 0;
}

// 0x43AE8
static void characterEditorHandleFolderButtonPressed()
{
    mouseGetPositionInWindow(gCharacterEditorWindow, &gCharacterEditorMouseX, &gCharacterEditorMouseY);
    soundPlayFile("ib3p1xx1");

    if (gCharacterEditorMouseX >= 208) {
        characterEditorSelectedItem = 41;
        characterEditorWindowSelectedFolder = EDITOR_FOLDER_KILLS;
    } else if (gCharacterEditorMouseX > 110) {
        characterEditorSelectedItem = 42;
        characterEditorWindowSelectedFolder = EDITOR_FOLDER_KARMA;
    } else {
        characterEditorSelectedItem = 40;
        characterEditorWindowSelectedFolder = EDITOR_FOLDER_PERKS;
    }

    characterEditorDrawFolders();
    characterEditorDrawCard();
}

// 0x43AF40
static void characterEditorHandleInfoButtonPressed(int eventCode)
{
    mouseGetPositionInWindow(gCharacterEditorWindow, &gCharacterEditorMouseX, &gCharacterEditorMouseY);

    switch (eventCode) {
    case 525:
        if (1) {
            // TODO: Original code is slightly different.
            double mouseY = gCharacterEditorMouseY;
            for (int index = 0; index < 7; index++) {
                double buttonTop = gCharacterEditorPrimaryStatY[index];
                double buttonBottom = gCharacterEditorPrimaryStatY[index] + 22;
                double allowance = 5.0 - index * 0.25;
                if (mouseY >= buttonTop - allowance && mouseY <= buttonBottom + allowance) {
                    characterEditorSelectedItem = index;
                    break;
                }
            }
        }
        break;
    case 526:
        if (gCharacterEditorIsCreationMode) {
            characterEditorSelectedItem = 7;
        } else {
            int offset = gCharacterEditorMouseY - 280;
            if (offset < 0) {
                offset = 0;
            }

            characterEditorSelectedItem = offset / 10 + 7;
        }
        break;
    case 527:
        if (!gCharacterEditorIsCreationMode) {
            fontSetCurrent(101);
            int offset = gCharacterEditorMouseY - 364;
            if (offset < 0) {
                offset = 0;
            }
            characterEditorSelectedItem = offset / (fontGetLineHeight() + 1) + 10;
        }
        break;
    case 528:
        if (1) {
            int offset = gCharacterEditorMouseY - 41;
            if (offset < 0) {
                offset = 0;
            }

            characterEditorSelectedItem = offset / 13 + 43;
        }
        break;
    case 529: {
        int offset = gCharacterEditorMouseY - 175;
        if (offset < 0) {
            offset = 0;
        }

        characterEditorSelectedItem = offset / 13 + 51;
        break;
    }
    case 530:
        characterEditorSelectedItem = 80;
        break;
    case 531:
        if (1) {
            int offset = gCharacterEditorMouseY - 27;
            if (offset < 0) {
                offset = 0;
            }

            gCharacterEditorCurrentSkill = (int)(offset * 0.092307694);
            if (gCharacterEditorCurrentSkill >= 18) {
                gCharacterEditorCurrentSkill = 17;
            }

            characterEditorSelectedItem = gCharacterEditorCurrentSkill + 61;
        }
        break;
    case 532:
        characterEditorSelectedItem = 79;
        break;
    case 533:
        characterEditorSelectedItem = 81;
        break;
    case 534:
        if (1) {
            fontSetCurrent(101);

            // TODO: Original code is slightly different.
            double mouseY = gCharacterEditorMouseY;
            double fontLineHeight = fontGetLineHeight();
            double y = 353.0;
            double step = fontGetLineHeight() + 3 + 0.56;
            int index;
            for (index = 0; index < 8; index++) {
                if (mouseY >= y - 4.0 && mouseY <= y + fontLineHeight) {
                    break;
                }
                y += step;
            }

            if (index == 8) {
                index = 7;
            }

            characterEditorSelectedItem = index + 82;
            if (gCharacterEditorMouseX >= 169) {
                characterEditorSelectedItem += 8;
            }
        }
        break;
    }

    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
    characterEditorDrawOptionalTraits();
    characterEditorDrawSkills(0);
    characterEditorDrawPcStats();
    characterEditorDrawFolders();
    characterEditorDrawDerivedStats();
    characterEditorDrawCard();
}

// 0x43B230
static void characterEditorHandleAdjustSkillButtonPressed(int keyCode)
{
    if (gCharacterEditorIsCreationMode) {
        return;
    }

    int unspentSp = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);
    _repFtime = 4;

    bool isUsingKeyboard = false;
    int rc = 0;

    switch (keyCode) {
    case KEY_PLUS:
    case KEY_UPPERCASE_N:
    case KEY_ARROW_RIGHT:
        isUsingKeyboard = true;
        keyCode = 521;
        break;
    case KEY_MINUS:
    case KEY_UPPERCASE_J:
    case KEY_ARROW_LEFT:
        isUsingKeyboard = true;
        keyCode = 523;
        break;
    }

    char title[64];
    char body1[64];
    char body2[64];

    const char* body[] = {
        body1,
        body2,
    };

    int repeatDelay = 0;
    for (;;) {
        _frame_time = _get_time();
        if (repeatDelay <= dbl_5018F0) {
            repeatDelay++;
        }

        if (repeatDelay == 1 || repeatDelay > dbl_5018F0) {
            if (repeatDelay > dbl_5018F0) {
                _repFtime++;
                if (_repFtime > 24) {
                    _repFtime = 24;
                }
            }

            rc = 1;
            if (keyCode == 521) {
                if (pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS) > 0) {
                    if (skillAdd(gDude, gCharacterEditorCurrentSkill) == -3) {
                        soundPlayFile("iisxxxx1");

                        sprintf(title, "%s:", skillGetName(gCharacterEditorCurrentSkill));
                        // At maximum level.
                        strcpy(body1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 132));
                        // Unable to increment it.
                        strcpy(body2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 133));
                        showDialogBox(title, body, 2, 192, 126, _colorTable[32328], NULL, _colorTable[32328], DIALOG_BOX_LARGE);
                        rc = -1;
                    }
                } else {
                    soundPlayFile("iisxxxx1");

                    // Not enough skill points available.
                    strcpy(title, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 136));
                    showDialogBox(title, NULL, 0, 192, 126, _colorTable[32328], NULL, _colorTable[32328], DIALOG_BOX_LARGE);
                    rc = -1;
                }
            } else if (keyCode == 523) {
                if (skillGetValue(gDude, gCharacterEditorCurrentSkill) <= gCharacterEditorSkillsBackup[gCharacterEditorCurrentSkill]) {
                    rc = 0;
                } else {
                    if (skillSub(gDude, gCharacterEditorCurrentSkill) == -2) {
                        rc = 0;
                    }
                }

                if (rc == 0) {
                    soundPlayFile("iisxxxx1");

                    sprintf(title, "%s:", skillGetName(gCharacterEditorCurrentSkill));
                    // At minimum level.
                    strcpy(body1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 134));
                    // Unable to decrement it.
                    strcpy(body2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 135));
                    showDialogBox(title, body, 2, 192, 126, _colorTable[32328], NULL, _colorTable[32328], DIALOG_BOX_LARGE);
                    rc = -1;
                }
            }

            characterEditorSelectedItem = gCharacterEditorCurrentSkill + 61;
            characterEditorDrawCard();
            characterEditorDrawSkills(1);

            int flags;
            if (rc == 1) {
                flags = ANIMATE;
            } else {
                flags = 0;
            }

            characterEditorDrawBigNumber(522, 228, flags, pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS), unspentSp, gCharacterEditorWindow);

            windowRefresh(gCharacterEditorWindow);
        }

        if (!isUsingKeyboard) {
            unspentSp = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);
            if (repeatDelay >= dbl_5018F0) {
                while (getTicksSince(_frame_time) < 1000 / _repFtime) {
                }
            } else {
                while (getTicksSince(_frame_time) < 1000 / 24) {
                }
            }

            int keyCode = _get_input();
            if (keyCode != 522 && keyCode != 524 && rc != -1) {
                continue;
            }
        }
        return;
    }
}

// 0x43B67C
static void characterEditorToggleTaggedSkill(int skill)
{
    int insertionIndex;

    insertionIndex = 0;
    for (int index = 3; index >= 0; index--) {
        if (gCharacterEditorTempTaggedSkills[index] != -1) {
            break;
        }
        insertionIndex++;
    }

    if (gCharacterEditorIsCreationMode) {
        insertionIndex -= 1;
    }

    gCharacterEditorOldTaggedSkillCount = insertionIndex;

    if (skill == gCharacterEditorTempTaggedSkills[0] || skill == gCharacterEditorTempTaggedSkills[1] || skill == gCharacterEditorTempTaggedSkills[2] || skill == gCharacterEditorTempTaggedSkills[3]) {
        if (skill == gCharacterEditorTempTaggedSkills[0]) {
            gCharacterEditorTempTaggedSkills[0] = gCharacterEditorTempTaggedSkills[1];
            gCharacterEditorTempTaggedSkills[1] = gCharacterEditorTempTaggedSkills[2];
            gCharacterEditorTempTaggedSkills[2] = -1;
        } else if (skill == gCharacterEditorTempTaggedSkills[1]) {
            gCharacterEditorTempTaggedSkills[1] = gCharacterEditorTempTaggedSkills[2];
            gCharacterEditorTempTaggedSkills[2] = -1;
        } else {
            gCharacterEditorTempTaggedSkills[2] = -1;
        }
    } else {
        if (gCharacterEditorTaggedSkillCount > 0) {
            insertionIndex = 0;
            for (int index = 0; index < 3; index++) {
                if (gCharacterEditorTempTaggedSkills[index] == -1) {
                    break;
                }
                insertionIndex++;
            }
            gCharacterEditorTempTaggedSkills[insertionIndex] = skill;
        } else {
            soundPlayFile("iisxxxx1");

            char line1[128];
            strcpy(line1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 140));

            char line2[128];
            strcpy(line2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 141));

            const char* lines[] = { line2 };
            showDialogBox(line1, lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], 0);
        }
    }

    insertionIndex = 0;
    for (int index = 3; index >= 0; index--) {
        if (gCharacterEditorTempTaggedSkills[index] != -1) {
            break;
        }
        insertionIndex++;
    }

    if (gCharacterEditorIsCreationMode) {
        insertionIndex -= 1;
    }

    gCharacterEditorTaggedSkillCount = insertionIndex;

    characterEditorSelectedItem = skill + 61;
    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
    characterEditorDrawDerivedStats();
    characterEditorDrawSkills(2);
    characterEditorDrawCard();
    windowRefresh(gCharacterEditorWindow);
}

// 0x43B8A8
static void characterEditorDrawOptionalTraits()
{
    int v0 = -1;
    int i;
    int color;
    const char* traitName;
    double step;
    double y;

    if (gCharacterEditorIsCreationMode != 1) {
        return;
    }

    if (characterEditorSelectedItem >= 82 && characterEditorSelectedItem < 98) {
        v0 = characterEditorSelectedItem - 82;
    }

    blitBufferToBuffer(gCharacterEditorWindowBackgroundBuffer + 640 * 353 + 47, 245, 100, 640, gCharacterEditorWindowBuffer + 640 * 353 + 47, 640);

    fontSetCurrent(101);

    traitsSetSelected(gCharacterEditorTempTraits[0], gCharacterEditorTempTraits[1]);

    step = fontGetLineHeight() + 3 + 0.56;
    y = 353;
    for (i = 0; i < 8; i++) {
        if (i == v0) {
            if (i != gCharacterEditorTempTraits[0] && i != gCharacterEditorTempTraits[1]) {
                color = _colorTable[32747];
            } else {
                color = _colorTable[32767];
            }

            gCharacterEditorFolderCardFrmId = traitGetFrmId(i);
            gCharacterEditorFolderCardTitle = traitGetName(i);
            gCharacterEditorFolderCardSubtitle = NULL;
            gCharacterEditorFolderCardDescription = traitGetDescription(i);
        } else {
            if (i != gCharacterEditorTempTraits[0] && i != gCharacterEditorTempTraits[1]) {
                color = _colorTable[992];
            } else {
                color = _colorTable[21140];
            }
        }

        traitName = traitGetName(i);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * (int)y + 47, traitName, 640, 640, color);
        y += step;
    }

    y = 353;
    for (i = 8; i < 16; i++) {
        if (i == v0) {
            if (i != gCharacterEditorTempTraits[0] && i != gCharacterEditorTempTraits[1]) {
                color = _colorTable[32747];
            } else {
                color = _colorTable[32767];
            }

            gCharacterEditorFolderCardFrmId = traitGetFrmId(i);
            gCharacterEditorFolderCardTitle = traitGetName(i);
            gCharacterEditorFolderCardSubtitle = NULL;
            gCharacterEditorFolderCardDescription = traitGetDescription(i);
        } else {
            if (i != gCharacterEditorTempTraits[0] && i != gCharacterEditorTempTraits[1]) {
                color = _colorTable[992];
            } else {
                color = _colorTable[21140];
            }
        }

        traitName = traitGetName(i);
        fontDrawText(gCharacterEditorWindowBuffer + 640 * (int)y + 199, traitName, 640, 640, color);
        y += step;
    }
}

// 0x43BB0C
static void characterEditorToggleOptionalTrait(int trait)
{
    if (trait == gCharacterEditorTempTraits[0] || trait == gCharacterEditorTempTraits[1]) {
        if (trait == gCharacterEditorTempTraits[0]) {
            gCharacterEditorTempTraits[0] = gCharacterEditorTempTraits[1];
            gCharacterEditorTempTraits[1] = -1;
        } else {
            gCharacterEditorTempTraits[1] = -1;
        }
    } else {
        if (gCharacterEditorTempTraitCount == 0) {
            soundPlayFile("iisxxxx1");

            char line1[128];
            strcpy(line1, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 148));

            char line2[128];
            strcpy(line2, getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 149));

            const char* lines = { line2 };
            showDialogBox(line1, &lines, 1, 192, 126, _colorTable[32328], 0, _colorTable[32328], 0);
        } else {
            for (int index = 0; index < 2; index++) {
                if (gCharacterEditorTempTraits[index] == -1) {
                    gCharacterEditorTempTraits[index] = trait;
                    break;
                }
            }
        }
    }

    gCharacterEditorTempTraitCount = 0;
    for (int index = 1; index != 0; index--) {
        if (gCharacterEditorTempTraits[index] != -1) {
            break;
        }
        gCharacterEditorTempTraitCount++;
    }

    characterEditorSelectedItem = trait + EDITOR_FIRST_TRAIT;

    characterEditorDrawOptionalTraits();
    characterEditorDrawSkills(0);
    critterUpdateDerivedStats(gDude);
    characterEditorDrawBigNumber(126, 282, 0, gCharacterEditorRemainingCharacterPoints, 0, gCharacterEditorWindow);
    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, false, 0);
    characterEditorDrawDerivedStats();
    characterEditorDrawCard();
    windowRefresh(gCharacterEditorWindow);
}

// 0x43BCE0
static void characterEditorDrawKarmaFolder()
{
    char* msg;
    char formattedText[256];

    characterEditorFolderViewClear();

    bool hasSelection = false;
    for (int index = 0; index < gKarmaEntriesLength; index++) {
        KarmaEntry* karmaDescription = &(gKarmaEntries[index]);
        if (karmaDescription->gvar == GVAR_PLAYER_REPUTATION) {
            int reputation;
            for (reputation = 0; reputation < gGenericReputationEntriesLength; reputation++) {
                GenericReputationEntry* reputationDescription = &(gGenericReputationEntries[reputation]);
                if (gGameGlobalVars[GVAR_PLAYER_REPUTATION] >= reputationDescription->threshold) {
                    break;
                }
            }

            if (reputation != gGenericReputationEntriesLength) {
                GenericReputationEntry* reputationDescription = &(gGenericReputationEntries[reputation]);

                char reputationValue[32];
                compat_itoa(gGameGlobalVars[GVAR_PLAYER_REPUTATION], reputationValue, 10);

                sprintf(formattedText,
                    "%s: %s (%s)",
                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 125),
                    reputationValue,
                    getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, reputationDescription->name));

                if (characterEditorFolderViewDrawString(formattedText)) {
                    gCharacterEditorFolderCardFrmId = karmaDescription->art_num;
                    gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 125);
                    gCharacterEditorFolderCardSubtitle = NULL;
                    gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, karmaDescription->description);
                    hasSelection = true;
                }
            }
        } else {
            if (gGameGlobalVars[karmaDescription->gvar] != 0) {
                msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, karmaDescription->name);
                if (characterEditorFolderViewDrawString(msg)) {
                    gCharacterEditorFolderCardFrmId = karmaDescription->art_num;
                    gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, karmaDescription->name);
                    gCharacterEditorFolderCardSubtitle = NULL;
                    gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, karmaDescription->description);
                    hasSelection = true;
                }
            }
        }
    }

    bool hasTownReputationHeading = false;
    for (int index = 0; index < TOWN_REPUTATION_COUNT; index++) {
        const TownReputationEntry* pair = &(gTownReputationEntries[index]);
        if (_wmAreaIsKnown(pair->city)) {
            if (!hasTownReputationHeading) {
                msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4000);
                if (characterEditorFolderViewDrawHeading(msg)) {
                    gCharacterEditorFolderCardFrmId = 48;
                    gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4000);
                    gCharacterEditorFolderCardSubtitle = NULL;
                    gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4100);
                }
                hasTownReputationHeading = true;
            }

            char cityShortName[40];
            _wmGetAreaIdxName(pair->city, cityShortName);

            int townReputation = gGameGlobalVars[pair->gvar];

            int townReputationGraphicId;
            int townReputationBaseMessageId;

            if (townReputation < -30) {
                townReputationGraphicId = 150;
                townReputationBaseMessageId = 2006; // Vilified
            } else if (townReputation < -15) {
                townReputationGraphicId = 153;
                townReputationBaseMessageId = 2005; // Hated
            } else if (townReputation < 0) {
                townReputationGraphicId = 153;
                townReputationBaseMessageId = 2004; // Antipathy
            } else if (townReputation == 0) {
                townReputationGraphicId = 141;
                townReputationBaseMessageId = 2003; // Neutral
            } else if (townReputation < 15) {
                townReputationGraphicId = 137;
                townReputationBaseMessageId = 2002; // Accepted
            } else if (townReputation < 30) {
                townReputationGraphicId = 137;
                townReputationBaseMessageId = 2001; // Liked
            } else {
                townReputationGraphicId = 135;
                townReputationBaseMessageId = 2000; // Idolized
            }

            msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, townReputationBaseMessageId);
            sprintf(formattedText,
                "%s: %s",
                cityShortName,
                msg);

            if (characterEditorFolderViewDrawString(formattedText)) {
                gCharacterEditorFolderCardFrmId = townReputationGraphicId;
                gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, townReputationBaseMessageId);
                gCharacterEditorFolderCardSubtitle = NULL;
                gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, townReputationBaseMessageId + 100);
                hasSelection = 1;
            }
        }
    }

    bool hasAddictionsHeading = false;
    for (int index = 0; index < ADDICTION_REPUTATION_COUNT; index++) {
        if (gGameGlobalVars[gAddictionReputationVars[index]] != 0) {
            if (!hasAddictionsHeading) {
                // Addictions
                msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4001);
                if (characterEditorFolderViewDrawHeading(msg)) {
                    gCharacterEditorFolderCardFrmId = 53;
                    gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4001);
                    gCharacterEditorFolderCardSubtitle = NULL;
                    gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 4101);
                    hasSelection = 1;
                }
                hasAddictionsHeading = true;
            }

            msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 1004 + index);
            if (characterEditorFolderViewDrawString(msg)) {
                gCharacterEditorFolderCardFrmId = gAddictionReputationFrmIds[index];
                gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 1004 + index);
                gCharacterEditorFolderCardSubtitle = NULL;
                gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 1104 + index);
                hasSelection = 1;
            }
        }
    }

    if (!hasSelection) {
        // SFALL: Custom karma folder.
        gCharacterEditorFolderCardFrmId = customKarmaFolderGetFrmId();
        gCharacterEditorFolderCardTitle = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 125);
        gCharacterEditorFolderCardSubtitle = NULL;
        gCharacterEditorFolderCardDescription = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 128);
    }
}

// 0x43C1B0
int characterEditorSave(File* stream)
{
    if (fileWriteInt32(stream, gCharacterEditorLastLevel) == -1)
        return -1;
    if (fileWriteUInt8(stream, gCharacterEditorHasFreePerk) == -1)
        return -1;

    return 0;
}

// 0x43C1E0
int characterEditorLoad(File* stream)
{
    if (fileReadInt32(stream, &gCharacterEditorLastLevel) == -1)
        return -1;
    if (fileReadUInt8(stream, &gCharacterEditorHasFreePerk) == -1)
        return -1;

    return 0;
}

// 0x43C20C
void characterEditorReset()
{
    gCharacterEditorRemainingCharacterPoints = 5;
    gCharacterEditorLastLevel = 1;
}

// level up if needed
//
// 0x43C228
static int characterEditorUpdateLevel()
{
    int level = pcGetStat(PC_STAT_LEVEL);
    if (level != gCharacterEditorLastLevel && level <= PC_LEVEL_MAX) {
        for (int nextLevel = gCharacterEditorLastLevel + 1; nextLevel <= level; nextLevel++) {
            int sp = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);
            sp += 5;
            sp += critterGetBaseStatWithTraitModifier(gDude, STAT_INTELLIGENCE) * 2;
            sp += perkGetRank(gDude, PERK_EDUCATED) * 2;
            sp += traitIsSelected(TRAIT_SKILLED) * 5;
            if (traitIsSelected(TRAIT_GIFTED)) {
                sp -= 5;
                if (sp < 0) {
                    sp = 0;
                }
            }
            if (sp > 99) {
                sp = 99;
            }

            pcSetStat(PC_STAT_UNSPENT_SKILL_POINTS, sp);

            int selectedPerksCount = 0;
            for (int perk = 0; perk < PERK_COUNT; perk++) {
                if (perkGetRank(gDude, perk) != 0) {
                    selectedPerksCount += 1;
                    if (selectedPerksCount >= 37) {
                        break;
                    }
                }
            }

            if (selectedPerksCount < 37) {
                int progression = 3;
                if (traitIsSelected(TRAIT_SKILLED)) {
                    progression += 1;
                }

                if (nextLevel % progression == 0) {
                    gCharacterEditorHasFreePerk = 1;
                }
            }
        }
    }

    if (gCharacterEditorHasFreePerk != 0) {
        characterEditorWindowSelectedFolder = 0;
        characterEditorDrawFolders();
        windowRefresh(gCharacterEditorWindow);

        int rc = perkDialogShow();
        if (rc == -1) {
            debugPrint("\n *** Error running perks dialog! ***\n");
            return -1;
        } else if (rc == 0) {
            characterEditorDrawFolders();
        } else if (rc == 1) {
            characterEditorDrawFolders();
            gCharacterEditorHasFreePerk = 0;
        }
    }

    gCharacterEditorLastLevel = level;

    return 1;
}

// 0x43C398
static void perkDialogRefreshPerks()
{
    blitBufferToBuffer(
        gPerkDialogBackgroundBuffer + 280,
        293,
        PERK_WINDOW_HEIGHT,
        PERK_WINDOW_WIDTH,
        gPerkDialogWindowBuffer + 280,
        PERK_WINDOW_WIDTH);

    perkDialogDrawPerks();

    // NOTE: Original code is slightly different, but basically does the same thing.
    int perk = gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value;
    int perkFrmId = perkGetFrmId(perk);
    char* perkName = perkGetName(perk);
    char* perkDescription = perkGetDescription(perk);
    char* perkRank = NULL;
    char perkRankBuffer[32];

    int rank = perkGetRank(gDude, perk);
    if (rank != 0) {
        sprintf(perkRankBuffer, "(%d)", rank);
        perkRank = perkRankBuffer;
    }

    perkDialogDrawCard(perkFrmId, perkName, perkRank, perkDescription);

    windowRefresh(gPerkDialogWindow);
}

// 0x43C4F0
static int perkDialogShow()
{
    gPerkDialogTopLine = 0;
    gPerkDialogCurrentLine = 0;
    gPerkDialogCardFrmId = -1;
    gPerkDialogCardTitle[0] = '\0';
    gPerkDialogCardDrawn = false;

    CacheEntry* backgroundFrmHandle;
    int backgroundWidth;
    int backgroundHeight;
    int fid = buildFid(OBJ_TYPE_INTERFACE, 86, 0, 0, 0);
    gPerkDialogBackgroundBuffer = artLockFrameDataReturningSize(fid, &backgroundFrmHandle, &backgroundWidth, &backgroundHeight);
    if (gPerkDialogBackgroundBuffer == NULL) {
        debugPrint("\n *** Error running perks dialog window ***\n");
        return -1;
    }

    // Maintain original position in original resolution, otherwise center it.
    int perkWindowX = screenGetWidth() != 640
        ? (screenGetWidth() - PERK_WINDOW_WIDTH) / 2
        : PERK_WINDOW_X;
    int perkWindowY = screenGetHeight() != 480
        ? (screenGetHeight() - PERK_WINDOW_HEIGHT) / 2
        : PERK_WINDOW_Y;
    gPerkDialogWindow = windowCreate(perkWindowX, perkWindowY, PERK_WINDOW_WIDTH, PERK_WINDOW_HEIGHT, 256, WINDOW_FLAG_0x10 | WINDOW_FLAG_0x02);
    if (gPerkDialogWindow == -1) {
        artUnlock(backgroundFrmHandle);
        debugPrint("\n *** Error running perks dialog window ***\n");
        return -1;
    }

    gPerkDialogWindowBuffer = windowGetBuffer(gPerkDialogWindow);
    memcpy(gPerkDialogWindowBuffer, gPerkDialogBackgroundBuffer, PERK_WINDOW_WIDTH * PERK_WINDOW_HEIGHT);

    int btn;

    btn = buttonCreate(gPerkDialogWindow,
        48,
        186,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        500,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    btn = buttonCreate(gPerkDialogWindow,
        153,
        186,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP].height,
        -1,
        -1,
        -1,
        502,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LITTLE_RED_BUTTON_UP],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_LILTTLE_RED_BUTTON_DOWN],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, _gsound_red_butt_release);
    }

    btn = buttonCreate(gPerkDialogWindow,
        25,
        46,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_UP_ARROW_ON].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_UP_ARROW_ON].height,
        -1,
        574,
        572,
        574,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_UP_ARROW_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_UP_ARROW_ON],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, NULL);
    }

    btn = buttonCreate(gPerkDialogWindow,
        25,
        47 + gCharacterEditorFrmSize[EDITOR_GRAPHIC_UP_ARROW_ON].height,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_UP_ARROW_ON].width,
        gCharacterEditorFrmSize[EDITOR_GRAPHIC_UP_ARROW_ON].height,
        -1,
        575,
        573,
        575,
        gCharacterEditorFrmData[EDITOR_GRAPHIC_DOWN_ARROW_OFF],
        gCharacterEditorFrmData[EDITOR_GRAPHIC_DOWN_ARROW_ON],
        NULL,
        BUTTON_FLAG_TRANSPARENT);
    if (btn != -1) {
        buttonSetCallbacks(btn, _gsound_red_butt_press, NULL);
    }

    buttonCreate(gPerkDialogWindow,
        PERK_WINDOW_LIST_X,
        PERK_WINDOW_LIST_Y,
        PERK_WINDOW_LIST_WIDTH,
        PERK_WINDOW_LIST_HEIGHT,
        -1,
        -1,
        -1,
        501,
        NULL,
        NULL,
        NULL,
        BUTTON_FLAG_TRANSPARENT);

    fontSetCurrent(103);

    const char* msg;

    // PICK A NEW PERK
    msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 152);
    fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 16 + 49, msg, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[18979]);

    // DONE
    msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 100);
    fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 186 + 69, msg, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[18979]);

    // CANCEL
    msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 102);
    fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 186 + 171, msg, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[18979]);

    int count = perkDialogDrawPerks();

    // NOTE: Original code is slightly different, but does the same thing.
    int perk = gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value;
    int perkFrmId = perkGetFrmId(perk);
    char* perkName = perkGetName(perk);
    char* perkDescription = perkGetDescription(perk);
    char* perkRank = NULL;
    char perkRankBuffer[32];

    int rank = perkGetRank(gDude, perk);
    if (rank != 0) {
        sprintf(perkRankBuffer, "(%d)", rank);
        perkRank = perkRankBuffer;
    }

    perkDialogDrawCard(perkFrmId, perkName, perkRank, perkDescription);
    windowRefresh(gPerkDialogWindow);

    int rc = perkDialogHandleInput(count, perkDialogRefreshPerks);

    if (rc == 1) {
        if (perkAdd(gDude, gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value) == -1) {
            debugPrint("\n*** Unable to add perk! ***\n");
            rc = 2;
        }
    }

    rc &= 1;

    if (rc != 0) {
        if (perkGetRank(gDude, PERK_TAG) != 0 && gCharacterEditorPerksBackup[PERK_TAG] == 0) {
            if (!perkDialogHandleTagPerk()) {
                perkRemove(gDude, PERK_TAG);
            }
        } else if (perkGetRank(gDude, PERK_MUTATE) != 0 && gCharacterEditorPerksBackup[PERK_MUTATE] == 0) {
            if (!perkDialogHandleMutatePerk()) {
                perkRemove(gDude, PERK_MUTATE);
            }
        } else if (perkGetRank(gDude, PERK_LIFEGIVER) != gCharacterEditorPerksBackup[PERK_LIFEGIVER]) {
            int maxHp = critterGetBonusStat(gDude, STAT_MAXIMUM_HIT_POINTS);
            critterSetBonusStat(gDude, STAT_MAXIMUM_HIT_POINTS, maxHp + 4);
            critterAdjustHitPoints(gDude, 4);
        } else if (perkGetRank(gDude, PERK_EDUCATED) != gCharacterEditorPerksBackup[PERK_EDUCATED]) {
            int sp = pcGetStat(PC_STAT_UNSPENT_SKILL_POINTS);
            pcSetStat(PC_STAT_UNSPENT_SKILL_POINTS, sp + 2);
        }
    }

    characterEditorDrawSkills(0);
    characterEditorDrawPrimaryStat(RENDER_ALL_STATS, 0, 0);
    characterEditorDrawPcStats();
    characterEditorDrawDerivedStats();
    characterEditorDrawFolders();
    characterEditorDrawCard();
    windowRefresh(gCharacterEditorWindow);

    artUnlock(backgroundFrmHandle);

    windowDestroy(gPerkDialogWindow);

    return rc;
}

// 0x43CACC
static int perkDialogHandleInput(int count, void (*refreshProc)())
{
    fontSetCurrent(101);

    int v3 = count - 11;

    int height = fontGetLineHeight();
    gPerkDialogPreviousCurrentLine = -2;
    int v16 = height + 2;

    int v7 = 0;

    int rc = 0;
    while (rc == 0) {
        int keyCode = _get_input();
        int v19 = 0;

        if (keyCode == 500) {
            rc = 1;
        } else if (keyCode == KEY_RETURN) {
            soundPlayFile("ib1p1xx1");
            rc = 1;
        } else if (keyCode == 501) {
            mouseGetPositionInWindow(gPerkDialogWindow, &gCharacterEditorMouseX, &gCharacterEditorMouseY);
            gPerkDialogCurrentLine = (gCharacterEditorMouseY - PERK_WINDOW_LIST_Y) / v16;
            if (gPerkDialogCurrentLine >= 0) {
                if (count - 1 < gPerkDialogCurrentLine)
                    gPerkDialogCurrentLine = count - 1;
            } else {
                gPerkDialogCurrentLine = 0;
            }

            if (gPerkDialogCurrentLine == gPerkDialogPreviousCurrentLine) {
                soundPlayFile("ib1p1xx1");
                rc = 1;
            }
            gPerkDialogPreviousCurrentLine = gPerkDialogCurrentLine;
            refreshProc();
        } else if (keyCode == 502 || keyCode == KEY_ESCAPE || _game_user_wants_to_quit != 0) {
            rc = 2;
        } else {
            switch (keyCode) {
            case KEY_ARROW_UP:
                gPerkDialogPreviousCurrentLine = -2;

                gPerkDialogTopLine--;
                if (gPerkDialogTopLine < 0) {
                    gPerkDialogTopLine = 0;

                    gPerkDialogCurrentLine--;
                    if (gPerkDialogCurrentLine < 0) {
                        gPerkDialogCurrentLine = 0;
                    }
                }

                refreshProc();
                break;
            case KEY_PAGE_UP:
                gPerkDialogPreviousCurrentLine = -2;

                for (int index = 0; index < 11; index++) {
                    gPerkDialogTopLine--;
                    if (gPerkDialogTopLine < 0) {
                        gPerkDialogTopLine = 0;

                        gPerkDialogCurrentLine--;
                        if (gPerkDialogCurrentLine < 0) {
                            gPerkDialogCurrentLine = 0;
                        }
                    }
                }

                refreshProc();
                break;
            case KEY_ARROW_DOWN:
                gPerkDialogPreviousCurrentLine = -2;

                if (count > 11) {
                    gPerkDialogTopLine++;
                    if (gPerkDialogTopLine > count - 11) {
                        gPerkDialogTopLine = count - 11;

                        gPerkDialogCurrentLine++;
                        if (gPerkDialogCurrentLine > 10) {
                            gPerkDialogCurrentLine = 10;
                        }
                    }
                } else {
                    gPerkDialogCurrentLine++;
                    if (gPerkDialogCurrentLine > count - 1) {
                        gPerkDialogCurrentLine = count - 1;
                    }
                }

                refreshProc();
                break;
            case KEY_PAGE_DOWN:
                gPerkDialogPreviousCurrentLine = -2;

                for (int index = 0; index < 11; index++) {
                    if (count > 11) {
                        gPerkDialogTopLine++;
                        if (gPerkDialogTopLine > count - 11) {
                            gPerkDialogTopLine = count - 11;

                            gPerkDialogCurrentLine++;
                            if (gPerkDialogCurrentLine > 10) {
                                gPerkDialogCurrentLine = 10;
                            }
                        }
                    } else {
                        gPerkDialogCurrentLine++;
                        if (gPerkDialogCurrentLine > count - 1) {
                            gPerkDialogCurrentLine = count - 1;
                        }
                    }
                }

                refreshProc();
                break;
            case 572:
                _repFtime = 4;
                gPerkDialogPreviousCurrentLine = -2;

                do {
                    _frame_time = _get_time();
                    if (v19 <= dbl_5019BE) {
                        v19++;
                    }

                    if (v19 == 1 || v19 > dbl_5019BE) {
                        if (v19 > dbl_5019BE) {
                            _repFtime++;
                            if (_repFtime > 24) {
                                _repFtime = 24;
                            }
                        }

                        gPerkDialogTopLine--;
                        if (gPerkDialogTopLine < 0) {
                            gPerkDialogTopLine = 0;

                            gPerkDialogCurrentLine--;
                            if (gPerkDialogCurrentLine < 0) {
                                gPerkDialogCurrentLine = 0;
                            }
                        }
                        refreshProc();
                    }

                    if (v19 < dbl_5019BE) {
                        while (getTicksSince(_frame_time) < 1000 / 24) {
                        }
                    } else {
                        while (getTicksSince(_frame_time) < 1000 / _repFtime) {
                        }
                    }
                } while (_get_input() != 574);

                break;
            case 573:
                gPerkDialogPreviousCurrentLine = -2;
                _repFtime = 4;

                if (count > 11) {
                    do {
                        _frame_time = _get_time();
                        if (v19 <= dbl_5019BE) {
                            v19++;
                        }

                        if (v19 == 1 || v19 > dbl_5019BE) {
                            if (v19 > dbl_5019BE) {
                                _repFtime++;
                                if (_repFtime > 24) {
                                    _repFtime = 24;
                                }
                            }

                            gPerkDialogTopLine++;
                            if (gPerkDialogTopLine > count - 11) {
                                gPerkDialogTopLine = count - 11;

                                gPerkDialogCurrentLine++;
                                if (gPerkDialogCurrentLine > 10) {
                                    gPerkDialogCurrentLine = 10;
                                }
                            }

                            refreshProc();
                        }

                        if (v19 < dbl_5019BE) {
                            while (getTicksSince(_frame_time) < 1000 / 24) {
                            }
                        } else {
                            while (getTicksSince(_frame_time) < 1000 / _repFtime) {
                            }
                        }
                    } while (_get_input() != 575);
                } else {
                    do {
                        _frame_time = _get_time();
                        if (v19 <= dbl_5019BE) {
                            v19++;
                        }

                        if (v19 == 1 || v19 > dbl_5019BE) {
                            if (v19 > dbl_5019BE) {
                                _repFtime++;
                                if (_repFtime > 24) {
                                    _repFtime = 24;
                                }
                            }

                            gPerkDialogCurrentLine++;
                            if (gPerkDialogCurrentLine > count - 1) {
                                gPerkDialogCurrentLine = count - 1;
                            }

                            refreshProc();
                        }

                        if (v19 < dbl_5019BE) {
                            while (getTicksSince(_frame_time) < 1000 / 24) {
                            }
                        } else {
                            while (getTicksSince(_frame_time) < 1000 / _repFtime) {
                            }
                        }
                    } while (_get_input() != 575);
                }
                break;
            case KEY_HOME:
                gPerkDialogTopLine = 0;
                gPerkDialogCurrentLine = 0;
                gPerkDialogPreviousCurrentLine = -2;
                refreshProc();
                break;
            case KEY_END:
                gPerkDialogPreviousCurrentLine = -2;
                if (count > 11) {
                    gPerkDialogTopLine = count - 11;
                    gPerkDialogCurrentLine = 10;
                } else {
                    gPerkDialogCurrentLine = count - 1;
                }
                refreshProc();
                break;
            default:
                if (getTicksSince(_frame_time) > 700) {
                    _frame_time = _get_time();
                    gPerkDialogPreviousCurrentLine = -2;
                }
                break;
            }
        }
    }

    return rc;
}

// 0x43D0BC
static int perkDialogDrawPerks()
{
    blitBufferToBuffer(
        gPerkDialogBackgroundBuffer + PERK_WINDOW_WIDTH * 43 + 45,
        192,
        129,
        PERK_WINDOW_WIDTH,
        gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 43 + 45,
        PERK_WINDOW_WIDTH);

    fontSetCurrent(101);

    int perks[PERK_COUNT];
    int count = perkGetAvailablePerks(gDude, perks);
    if (count == 0) {
        return 0;
    }

    for (int perk = 0; perk < PERK_COUNT; perk++) {
        gPerkDialogOptionList[perk].value = 0;
        gPerkDialogOptionList[perk].name = NULL;
    }

    for (int index = 0; index < count; index++) {
        gPerkDialogOptionList[index].value = perks[index];
        gPerkDialogOptionList[index].name = perkGetName(perks[index]);
    }

    qsort(gPerkDialogOptionList, count, sizeof(*gPerkDialogOptionList), perkDialogOptionCompare);

    int v16 = count - gPerkDialogTopLine;
    if (v16 > 11) {
        v16 = 11;
    }

    v16 += gPerkDialogTopLine;

    int y = 43;
    int yStep = fontGetLineHeight() + 2;
    for (int index = gPerkDialogTopLine; index < v16; index++) {
        int color;
        if (index == gPerkDialogTopLine + gPerkDialogCurrentLine) {
            color = _colorTable[32747];
        } else {
            color = _colorTable[992];
        }

        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 45, gPerkDialogOptionList[index].name, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, color);

        if (perkGetRank(gDude, gPerkDialogOptionList[index].value) != 0) {
            char rankString[256];
            sprintf(rankString, "(%d)", perkGetRank(gDude, gPerkDialogOptionList[index].value));
            fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 207, rankString, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, color);
        }

        y += yStep;
    }

    return count;
}

// 0x43D2F8
static void perkDialogRefreshTraits()
{
    blitBufferToBuffer(gPerkDialogBackgroundBuffer + 280, 293, PERK_WINDOW_HEIGHT, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + 280, PERK_WINDOW_WIDTH);

    perkDialogDrawTraits(gPerkDialogOptionCount);

    char* traitName = gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].name;
    char* tratDescription = traitGetDescription(gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value);
    int frmId = traitGetFrmId(gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value);
    perkDialogDrawCard(frmId, traitName, NULL, tratDescription);

    windowRefresh(gPerkDialogWindow);
}

// 0x43D38C
static bool perkDialogHandleMutatePerk()
{
    gPerkDialogCardFrmId = -1;
    gPerkDialogCardTitle[0] = '\0';
    gPerkDialogCardDrawn = false;

    int traitCount = TRAITS_MAX_SELECTED_COUNT - 1;
    int traitIndex = 0;
    while (traitCount >= 0) {
        if (gCharacterEditorTempTraits[traitIndex] != -1) {
            break;
        }
        traitCount--;
        traitIndex++;
    }

    gCharacterEditorTempTraitCount = TRAITS_MAX_SELECTED_COUNT - traitIndex;

    bool result = true;
    if (gCharacterEditorTempTraitCount >= 1) {
        fontSetCurrent(103);

        blitBufferToBuffer(gPerkDialogBackgroundBuffer + PERK_WINDOW_WIDTH * 14 + 49, 206, fontGetLineHeight() + 2, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 15 + 49, PERK_WINDOW_WIDTH);

        // LOSE A TRAIT
        char* msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 154);
        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 16 + 49, msg, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[18979]);

        gPerkDialogOptionCount = 0;
        gPerkDialogCurrentLine = 0;
        gPerkDialogTopLine = 0;
        perkDialogRefreshTraits();

        int rc = perkDialogHandleInput(gCharacterEditorTempTraitCount, perkDialogRefreshTraits);
        if (rc == 1) {
            if (gPerkDialogCurrentLine == 0) {
                if (gCharacterEditorTempTraitCount == 1) {
                    gCharacterEditorTempTraits[0] = -1;
                    gCharacterEditorTempTraits[1] = -1;
                } else {
                    if (gPerkDialogOptionList[0].value == gCharacterEditorTempTraits[0]) {
                        gCharacterEditorTempTraits[0] = gCharacterEditorTempTraits[1];
                        gCharacterEditorTempTraits[1] = -1;
                    } else {
                        gCharacterEditorTempTraits[1] = -1;
                    }
                }
            } else {
                if (gPerkDialogOptionList[0].value == gCharacterEditorTempTraits[0]) {
                    gCharacterEditorTempTraits[1] = -1;
                } else {
                    gCharacterEditorTempTraits[0] = gCharacterEditorTempTraits[1];
                    gCharacterEditorTempTraits[1] = -1;
                }
            }
        } else {
            result = false;
        }
    }

    if (result) {
        fontSetCurrent(103);

        blitBufferToBuffer(gPerkDialogBackgroundBuffer + PERK_WINDOW_WIDTH * 14 + 49, 206, fontGetLineHeight() + 2, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 15 + 49, PERK_WINDOW_WIDTH);

        // PICK A NEW TRAIT
        char* msg = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 153);
        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 16 + 49, msg, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[18979]);

        gPerkDialogCurrentLine = 0;
        gPerkDialogTopLine = 0;
        gPerkDialogOptionCount = 1;

        perkDialogRefreshTraits();

        int count = 16 - gCharacterEditorTempTraitCount;
        if (count > 16) {
            count = 16;
        }

        int rc = perkDialogHandleInput(count, perkDialogRefreshTraits);
        if (rc == 1) {
            if (gCharacterEditorTempTraitCount != 0) {
                gCharacterEditorTempTraits[1] = gPerkDialogOptionList[gPerkDialogCurrentLine + gPerkDialogTopLine].value;
            } else {
                gCharacterEditorTempTraits[0] = gPerkDialogOptionList[gPerkDialogCurrentLine + gPerkDialogTopLine].value;
                gCharacterEditorTempTraits[1] = -1;
            }

            traitsSetSelected(gCharacterEditorTempTraits[0], gCharacterEditorTempTraits[1]);
        } else {
            result = false;
        }
    }

    if (!result) {
        memcpy(gCharacterEditorTempTraits, gCharacterEditorOptionalTraitsBackup, sizeof(gCharacterEditorTempTraits));
    }

    return result;
}

// 0x43D668
static void perkDialogRefreshSkills()
{
    blitBufferToBuffer(gPerkDialogBackgroundBuffer + 280, 293, PERK_WINDOW_HEIGHT, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + 280, PERK_WINDOW_WIDTH);

    perkDialogDrawSkills();

    char* name = gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].name;
    char* description = skillGetDescription(gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value);
    int frmId = skillGetFrmId(gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value);
    perkDialogDrawCard(frmId, name, NULL, description);

    windowRefresh(gPerkDialogWindow);
}

// 0x43D6F8
static bool perkDialogHandleTagPerk()
{
    fontSetCurrent(103);

    blitBufferToBuffer(gPerkDialogBackgroundBuffer + 573 * 14 + 49, 206, fontGetLineHeight() + 2, 573, gPerkDialogWindowBuffer + 573 * 15 + 49, 573);

    // PICK A NEW TAG SKILL
    char* messageListItemText = getmsg(&gCharacterEditorMessageList, &gCharacterEditorMessageListItem, 155);
    fontDrawText(gPerkDialogWindowBuffer + 573 * 16 + 49, messageListItemText, 573, 573, _colorTable[18979]);

    gPerkDialogCurrentLine = 0;
    gPerkDialogTopLine = 0;
    gPerkDialogCardFrmId = -1;
    gPerkDialogCardTitle[0] = '\0';
    gPerkDialogCardDrawn = false;
    perkDialogRefreshSkills();

    int rc = perkDialogHandleInput(gPerkDialogOptionCount, perkDialogRefreshSkills);
    if (rc != 1) {
        memcpy(gCharacterEditorTempTaggedSkills, gCharacterEditorTaggedSkillsBackup, sizeof(gCharacterEditorTempTaggedSkills));
        skillsSetTagged(gCharacterEditorTaggedSkillsBackup, NUM_TAGGED_SKILLS);
        return false;
    }

    gCharacterEditorTempTaggedSkills[3] = gPerkDialogOptionList[gPerkDialogTopLine + gPerkDialogCurrentLine].value;
    skillsSetTagged(gCharacterEditorTempTaggedSkills, NUM_TAGGED_SKILLS);

    return true;
}

// 0x43D81C
static void perkDialogDrawSkills()
{
    blitBufferToBuffer(gPerkDialogBackgroundBuffer + PERK_WINDOW_WIDTH * 43 + 45, 192, 129, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 43 + 45, PERK_WINDOW_WIDTH);

    fontSetCurrent(101);

    gPerkDialogOptionCount = 0;

    int y = 43;
    int yStep = fontGetLineHeight() + 2;

    for (int skill = 0; skill < SKILL_COUNT; skill++) {
        if (skill != gCharacterEditorTempTaggedSkills[0] && skill != gCharacterEditorTempTaggedSkills[1] && skill != gCharacterEditorTempTaggedSkills[2] && skill != gCharacterEditorTempTaggedSkills[3]) {
            gPerkDialogOptionList[gPerkDialogOptionCount].value = skill;
            gPerkDialogOptionList[gPerkDialogOptionCount].name = skillGetName(skill);
            gPerkDialogOptionCount++;
        }
    }

    qsort(gPerkDialogOptionList, gPerkDialogOptionCount, sizeof(*gPerkDialogOptionList), perkDialogOptionCompare);

    for (int index = gPerkDialogTopLine; index < gPerkDialogTopLine + 11; index++) {
        int color;
        if (index == gPerkDialogCurrentLine + gPerkDialogTopLine) {
            color = _colorTable[32747];
        } else {
            color = _colorTable[992];
        }

        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 45, gPerkDialogOptionList[index].name, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, color);
        y += yStep;
    }
}

// 0x43D960
static int perkDialogDrawTraits(int a1)
{
    blitBufferToBuffer(gPerkDialogBackgroundBuffer + PERK_WINDOW_WIDTH * 43 + 45, 192, 129, PERK_WINDOW_WIDTH, gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 43 + 45, PERK_WINDOW_WIDTH);

    fontSetCurrent(101);

    int y = 43;
    int yStep = fontGetLineHeight() + 2;

    if (a1 != 0) {
        int count = 0;
        for (int trait = 0; trait < TRAIT_COUNT; trait++) {
            if (trait != gCharacterEditorOptionalTraitsBackup[0] && trait != gCharacterEditorOptionalTraitsBackup[1]) {
                gPerkDialogOptionList[count].value = trait;
                gPerkDialogOptionList[count].name = traitGetName(trait);
                count++;
            }
        }

        qsort(gPerkDialogOptionList, count, sizeof(*gPerkDialogOptionList), perkDialogOptionCompare);

        for (int index = gPerkDialogTopLine; index < gPerkDialogTopLine + 11; index++) {
            int color;
            if (index == gPerkDialogCurrentLine + gPerkDialogTopLine) {
                color = _colorTable[32747];
            } else {
                color = _colorTable[992];
            }

            fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 45, gPerkDialogOptionList[index].name, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, color);
            y += yStep;
        }
    } else {
        // NOTE: Original code does not use loop.
        for (int index = 0; index < TRAITS_MAX_SELECTED_COUNT; index++) {
            gPerkDialogOptionList[index].value = gCharacterEditorTempTraits[index];
            gPerkDialogOptionList[index].name = traitGetName(gCharacterEditorTempTraits[index]);
        }

        if (gCharacterEditorTempTraitCount > 1) {
            qsort(gPerkDialogOptionList, gCharacterEditorTempTraitCount, sizeof(*gPerkDialogOptionList), perkDialogOptionCompare);
        }

        for (int index = 0; index < gCharacterEditorTempTraitCount; index++) {
            int color;
            if (index == gPerkDialogCurrentLine) {
                color = _colorTable[32747];
            } else {
                color = _colorTable[992];
            }

            fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 45, gPerkDialogOptionList[index].name, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, color);
            y += yStep;
        }
    }
    return 0;
}

// 0x43DB48
static int perkDialogOptionCompare(const void* a1, const void* a2)
{
    PerkDialogOption* v1 = (PerkDialogOption*)a1;
    PerkDialogOption* v2 = (PerkDialogOption*)a2;
    return strcmp(v1->name, v2->name);
}

// 0x43DB54
static int perkDialogDrawCard(int frmId, const char* name, const char* rank, char* description)
{
    int fid = buildFid(OBJ_TYPE_SKILLDEX, frmId, 0, 0, 0);

    CacheEntry* handle;
    int width;
    int height;
    unsigned char* data = artLockFrameDataReturningSize(fid, &handle, &width, &height);
    if (data == NULL) {
        return -1;
    }

    blitBufferToBuffer(data, width, height, width, gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 64 + 413, PERK_WINDOW_WIDTH);

    // Calculate width of transparent pixels on the left side of the image. This
    // space will be occupied by description (in addition to fixed width).
    int extraDescriptionWidth = 150;
    for (int y = 0; y < height; y++) {
        unsigned char* stride = data;
        for (int x = 0; x < width; x++) {
            if (_HighRGB_(*stride) < 2) {
                if (extraDescriptionWidth > x) {
                    extraDescriptionWidth = x;
                }
            }
            stride++;
        }
        data += width;
    }

    // Add gap between description and image.
    extraDescriptionWidth -= 8;
    if (extraDescriptionWidth < 0) {
        extraDescriptionWidth = 0;
    }

    fontSetCurrent(102);
    int nameHeight = fontGetLineHeight();

    fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * 27 + 280, name, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[0]);

    if (rank != NULL) {
        int rankX = fontGetStringWidth(name) + 280 + 8;
        fontSetCurrent(101);

        int rankHeight = fontGetLineHeight();
        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * (23 + nameHeight - rankHeight) + rankX, rank, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[0]);
    }

    windowDrawLine(gPerkDialogWindow, 280, 27 + nameHeight, 545, 27 + nameHeight, _colorTable[0]);
    windowDrawLine(gPerkDialogWindow, 280, 28 + nameHeight, 545, 28 + nameHeight, _colorTable[0]);

    fontSetCurrent(101);

    int yStep = fontGetLineHeight() + 1;
    int y = 70;

    short beginnings[WORD_WRAP_MAX_COUNT];
    short count;
    if (wordWrap(description, 133 + extraDescriptionWidth, beginnings, &count) != 0) {
        // FIXME: Leaks handle.
        return -1;
    }

    for (int index = 0; index < count - 1; index++) {
        char* beginning = description + beginnings[index];
        char* ending = description + beginnings[index + 1];

        char ch = *ending;
        *ending = '\0';

        fontDrawText(gPerkDialogWindowBuffer + PERK_WINDOW_WIDTH * y + 280, beginning, PERK_WINDOW_WIDTH, PERK_WINDOW_WIDTH, _colorTable[0]);

        *ending = ch;

        y += yStep;
    }

    if (frmId != gPerkDialogCardFrmId || strcmp(gPerkDialogCardTitle, name) != 0) {
        if (gPerkDialogCardDrawn) {
            soundPlayFile("isdxxxx1");
        }
    }

    strcpy(gPerkDialogCardTitle, name);
    gPerkDialogCardFrmId = frmId;
    gPerkDialogCardDrawn = true;

    artUnlock(handle);

    return 0;
}

// copy editor perks to character
//
// 0x43DEBC
static void _pop_perks()
{
    for (int perk = 0; perk < PERK_COUNT; perk++) {
        for (;;) {
            int rank = perkGetRank(gDude, perk);
            if (rank <= gCharacterEditorPerksBackup[perk]) {
                break;
            }

            perkRemove(gDude, perk);
        }
    }

    for (int i = 0; i < PERK_COUNT; i++) {
        for (;;) {
            int rank = perkGetRank(gDude, i);
            if (rank >= gCharacterEditorPerksBackup[i]) {
                break;
            }

            perkAdd(gDude, i);
        }
    }
}

// validate SPECIAL stats are <= 10
//
// 0x43DF50
static int _is_supper_bonus()
{
    for (int stat = 0; stat < 7; stat++) {
        int v1 = critterGetBaseStatWithTraitModifier(gDude, stat);
        int v2 = critterGetBonusStat(gDude, stat);
        if (v1 + v2 > 10) {
            return 1;
        }
    }

    return 0;
}

// 0x43DF8C
static int characterEditorFolderViewInit()
{
    gCharacterEditorKarmaFolderTopLine = 0;
    gCharacterEditorPerkFolderTopLine = 0;
    gCharacterEditorKillsFolderTopLine = 0;

    if (gCharacterEditorFolderViewScrollUpBtn == -1) {
        gCharacterEditorFolderViewScrollUpBtn = buttonCreate(gCharacterEditorWindow, 317, 364, gCharacterEditorFrmSize[22].width, gCharacterEditorFrmSize[22].height, -1, -1, -1, 17000, gCharacterEditorFrmData[21], gCharacterEditorFrmData[22], NULL, 32);
        if (gCharacterEditorFolderViewScrollUpBtn == -1) {
            return -1;
        }

        buttonSetCallbacks(gCharacterEditorFolderViewScrollUpBtn, _gsound_red_butt_press, NULL);
    }

    if (gCharacterEditorFolderViewScrollDownBtn == -1) {
        gCharacterEditorFolderViewScrollDownBtn = buttonCreate(gCharacterEditorWindow,
            317,
            365 + gCharacterEditorFrmSize[22].height,
            gCharacterEditorFrmSize[4].width,
            gCharacterEditorFrmSize[4].height,
            gCharacterEditorFolderViewScrollDownBtn,
            gCharacterEditorFolderViewScrollDownBtn,
            gCharacterEditorFolderViewScrollDownBtn,
            17001,
            gCharacterEditorFrmData[3],
            gCharacterEditorFrmData[4],
            0,
            32);
        if (gCharacterEditorFolderViewScrollDownBtn == -1) {
            buttonDestroy(gCharacterEditorFolderViewScrollUpBtn);
            return -1;
        }

        buttonSetCallbacks(gCharacterEditorFolderViewScrollDownBtn, _gsound_red_butt_press, NULL);
    }

    return 0;
}

// 0x43E0D4
static void characterEditorFolderViewScroll(int direction)
{
    int* v1;

    switch (characterEditorWindowSelectedFolder) {
    case EDITOR_FOLDER_PERKS:
        v1 = &gCharacterEditorPerkFolderTopLine;
        break;
    case EDITOR_FOLDER_KARMA:
        v1 = &gCharacterEditorKarmaFolderTopLine;
        break;
    case EDITOR_FOLDER_KILLS:
        v1 = &gCharacterEditorKillsFolderTopLine;
        break;
    default:
        return;
    }

    if (direction >= 0) {
        if (gCharacterEditorFolderViewMaxLines + gCharacterEditorFolderViewTopLine <= gCharacterEditorFolderViewCurrentLine) {
            gCharacterEditorFolderViewTopLine++;
            if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43 && characterEditorSelectedItem != 10) {
                characterEditorSelectedItem--;
            }
        }
    } else {
        if (gCharacterEditorFolderViewTopLine > 0) {
            gCharacterEditorFolderViewTopLine--;
            if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43 && gCharacterEditorFolderViewMaxLines + 9 > characterEditorSelectedItem) {
                characterEditorSelectedItem++;
            }
        }
    }

    *v1 = gCharacterEditorFolderViewTopLine;
    characterEditorDrawFolders();

    if (characterEditorSelectedItem >= 10 && characterEditorSelectedItem < 43) {
        blitBufferToBuffer(
            gCharacterEditorWindowBackgroundBuffer + 640 * 267 + 345,
            277,
            170,
            640,
            gCharacterEditorWindowBuffer + 640 * 267 + 345,
            640);
        characterEditorDrawCardWithOptions(gCharacterEditorFolderCardFrmId, gCharacterEditorFolderCardTitle, gCharacterEditorFolderCardSubtitle, gCharacterEditorFolderCardDescription);
    }
}

// 0x43E200
static void characterEditorFolderViewClear()
{
    int v0;

    gCharacterEditorFolderViewCurrentLine = 0;
    gCharacterEditorFolderViewNextY = 364;

    v0 = fontGetLineHeight();

    gCharacterEditorFolderViewMaxLines = 9;
    gCharacterEditorFolderViewOffsetY = v0 + 1;

    if (characterEditorSelectedItem < 10 || characterEditorSelectedItem >= 43)
        gCharacterEditorFolderViewHighlightedLine = -1;
    else
        gCharacterEditorFolderViewHighlightedLine = characterEditorSelectedItem - 10;

    if (characterEditorWindowSelectedFolder < 1) {
        if (characterEditorWindowSelectedFolder)
            return;

        gCharacterEditorFolderViewTopLine = gCharacterEditorPerkFolderTopLine;
    } else if (characterEditorWindowSelectedFolder == 1) {
        gCharacterEditorFolderViewTopLine = gCharacterEditorKarmaFolderTopLine;
    } else if (characterEditorWindowSelectedFolder == 2) {
        gCharacterEditorFolderViewTopLine = gCharacterEditorKillsFolderTopLine;
    }
}

// render heading string with line
//
// 0x43E28C
static int characterEditorFolderViewDrawHeading(const char* string)
{
    int lineHeight;
    int x;
    int y;
    int lineLen;
    int gap;
    int v8 = 0;

    if (gCharacterEditorFolderViewMaxLines + gCharacterEditorFolderViewTopLine > gCharacterEditorFolderViewCurrentLine) {
        if (gCharacterEditorFolderViewCurrentLine >= gCharacterEditorFolderViewTopLine) {
            if (gCharacterEditorFolderViewCurrentLine - gCharacterEditorFolderViewTopLine == gCharacterEditorFolderViewHighlightedLine) {
                v8 = 1;
            }
            lineHeight = fontGetLineHeight();
            x = 280;
            y = gCharacterEditorFolderViewNextY + lineHeight / 2;
            if (string != NULL) {
                gap = fontGetLetterSpacing();
                // TODO: Not sure about this.
                lineLen = fontGetStringWidth(string) + gap * 4;
                x = (x - lineLen) / 2;
                fontDrawText(gCharacterEditorWindowBuffer + 640 * gCharacterEditorFolderViewNextY + 34 + x + gap * 2, string, 640, 640, _colorTable[992]);
                windowDrawLine(gCharacterEditorWindow, 34 + x + lineLen, y, 34 + 280, y, _colorTable[992]);
            }
            windowDrawLine(gCharacterEditorWindow, 34, y, 34 + x, y, _colorTable[992]);
            gCharacterEditorFolderViewNextY += gCharacterEditorFolderViewOffsetY;
        }
        gCharacterEditorFolderViewCurrentLine++;
        return v8;
    } else {
        return 0;
    }
}

// 0x43E3D8
static bool characterEditorFolderViewDrawString(const char* string)
{
    bool success = false;
    int color;

    if (gCharacterEditorFolderViewMaxLines + gCharacterEditorFolderViewTopLine > gCharacterEditorFolderViewCurrentLine) {
        if (gCharacterEditorFolderViewCurrentLine >= gCharacterEditorFolderViewTopLine) {
            if (gCharacterEditorFolderViewCurrentLine - gCharacterEditorFolderViewTopLine == gCharacterEditorFolderViewHighlightedLine) {
                success = true;
                color = _colorTable[32747];
            } else {
                color = _colorTable[992];
            }

            fontDrawText(gCharacterEditorWindowBuffer + 640 * gCharacterEditorFolderViewNextY + 34, string, 640, 640, color);
            gCharacterEditorFolderViewNextY += gCharacterEditorFolderViewOffsetY;
        }

        gCharacterEditorFolderViewCurrentLine++;
    }

    return success;
}

// 0x43E470
static bool characterEditorFolderViewDrawKillsEntry(const char* name, int kills)
{
    char killsString[8];
    int color;
    int gap;

    bool success = false;
    if (gCharacterEditorFolderViewMaxLines + gCharacterEditorFolderViewTopLine > gCharacterEditorFolderViewCurrentLine) {
        if (gCharacterEditorFolderViewCurrentLine >= gCharacterEditorFolderViewTopLine) {
            if (gCharacterEditorFolderViewCurrentLine - gCharacterEditorFolderViewTopLine == gCharacterEditorFolderViewHighlightedLine) {
                color = _colorTable[32747];
                success = true;
            } else {
                color = _colorTable[992];
            }

            compat_itoa(kills, killsString, 10);
            int v6 = fontGetStringWidth(killsString);

            // TODO: Check.
            gap = fontGetLetterSpacing();
            int v11 = gCharacterEditorFolderViewNextY + fontGetLineHeight() / 2;

            fontDrawText(gCharacterEditorWindowBuffer + 640 * gCharacterEditorFolderViewNextY + 34, name, 640, 640, color);

            int v12 = fontGetStringWidth(name);
            windowDrawLine(gCharacterEditorWindow, 34 + v12 + gap, v11, 314 - v6 - gap, v11, color);

            fontDrawText(gCharacterEditorWindowBuffer + 640 * gCharacterEditorFolderViewNextY + 314 - v6, killsString, 640, 640, color);
            gCharacterEditorFolderViewNextY += gCharacterEditorFolderViewOffsetY;
        }

        gCharacterEditorFolderViewCurrentLine++;
    }

    return success;
}

// 0x43E5C4
static int karmaInit()
{
    const char* delim = " \t,";

    if (gKarmaEntries != NULL) {
        internal_free(gKarmaEntries);
        gKarmaEntries = NULL;
    }

    gKarmaEntriesLength = 0;

    File* stream = fileOpen("data\\karmavar.txt", "rt");
    if (stream == NULL) {
        return -1;
    }

    char string[256];
    while (fileReadString(string, 256, stream)) {
        KarmaEntry entry;

        char* pch = string;
        while (isspace(*pch & 0xFF)) {
            pch++;
        }

        if (*pch == '#') {
            continue;
        }

        char* tok = strtok(pch, delim);
        if (tok == NULL) {
            continue;
        }

        entry.gvar = atoi(tok);

        tok = strtok(NULL, delim);
        if (tok == NULL) {
            continue;
        }

        entry.art_num = atoi(tok);

        tok = strtok(NULL, delim);
        if (tok == NULL) {
            continue;
        }

        entry.name = atoi(tok);

        tok = strtok(NULL, delim);
        if (tok == NULL) {
            continue;
        }

        entry.description = atoi(tok);

        KarmaEntry* entries = (KarmaEntry*)internal_realloc(gKarmaEntries, sizeof(*entries) * (gKarmaEntriesLength + 1));
        if (entries == NULL) {
            fileClose(stream);

            return -1;
        }

        memcpy(&(entries[gKarmaEntriesLength]), &entry, sizeof(entry));

        gKarmaEntries = entries;
        gKarmaEntriesLength++;
    }

    qsort(gKarmaEntries, gKarmaEntriesLength, sizeof(*gKarmaEntries), karmaEntryCompare);

    fileClose(stream);

    return 0;
}

// NOTE: Inlined.
//
// 0x43E764
static void karmaFree()
{
    if (gKarmaEntries != NULL) {
        internal_free(gKarmaEntries);
        gKarmaEntries = NULL;
    }

    gKarmaEntriesLength = 0;
}

// 0x43E78C
static int karmaEntryCompare(const void* a1, const void* a2)
{
    KarmaEntry* v1 = (KarmaEntry*)a1;
    KarmaEntry* v2 = (KarmaEntry*)a2;
    return v1->gvar - v2->gvar;
}

// 0x43E798
static int genericReputationInit()
{
    const char* delim = " \t,";

    if (gGenericReputationEntries != NULL) {
        internal_free(gGenericReputationEntries);
        gGenericReputationEntries = NULL;
    }

    gGenericReputationEntriesLength = 0;

    File* stream = fileOpen("data\\genrep.txt", "rt");
    if (stream == NULL) {
        return -1;
    }

    char string[256];
    while (fileReadString(string, 256, stream)) {
        GenericReputationEntry entry;

        char* pch = string;
        while (isspace(*pch & 0xFF)) {
            pch++;
        }

        if (*pch == '#') {
            continue;
        }

        char* tok = strtok(pch, delim);
        if (tok == NULL) {
            continue;
        }

        entry.threshold = atoi(tok);

        tok = strtok(NULL, delim);
        if (tok == NULL) {
            continue;
        }

        entry.name = atoi(tok);

        GenericReputationEntry* entries = (GenericReputationEntry*)internal_realloc(gGenericReputationEntries, sizeof(*entries) * (gGenericReputationEntriesLength + 1));
        if (entries == NULL) {
            fileClose(stream);

            return -1;
        }

        memcpy(&(entries[gGenericReputationEntriesLength]), &entry, sizeof(entry));

        gGenericReputationEntries = entries;
        gGenericReputationEntriesLength++;
    }

    qsort(gGenericReputationEntries, gGenericReputationEntriesLength, sizeof(*gGenericReputationEntries), genericReputationCompare);

    fileClose(stream);

    return 0;
}

// NOTE: Inlined.
//
// 0x43E914
static void genericReputationFree()
{
    if (gGenericReputationEntries != NULL) {
        internal_free(gGenericReputationEntries);
        gGenericReputationEntries = NULL;
    }

    gGenericReputationEntriesLength = 0;
}

// 0x43E93C
static int genericReputationCompare(const void* a1, const void* a2)
{
    GenericReputationEntry* v1 = (GenericReputationEntry*)a1;
    GenericReputationEntry* v2 = (GenericReputationEntry*)a2;

    if (v2->threshold > v1->threshold) {
        return 1;
    } else if (v2->threshold < v1->threshold) {
        return -1;
    }
    return 0;
}

static void customKarmaFolderInit()
{
    char* karmaFrms = NULL;
    configGetString(&gSfallConfig, SFALL_CONFIG_MISC_KEY, SFALL_CONFIG_KARMA_FRMS_KEY, &karmaFrms);
    if (karmaFrms != NULL && karmaFrms[0] == '\0') {
        karmaFrms = NULL;
    }

    if (karmaFrms == NULL) {
        return;
    }

    char* karmaPoints = NULL;
    configGetString(&gSfallConfig, SFALL_CONFIG_MISC_KEY, SFALL_CONFIG_KARMA_POINTS_KEY, &karmaPoints);
    if (karmaPoints != NULL && karmaPoints[0] == '\0') {
        karmaPoints = NULL;
    }

    if (karmaPoints == NULL) {
        return;
    }

    int karmaFrmsCount = 0;
    for (char* pch = karmaFrms; pch != NULL; pch = strchr(pch + 1, ',')) {
        karmaFrmsCount++;
    }

    int karmaPointsCount = 0;
    for (char* pch = karmaPoints; pch != NULL; pch = strchr(pch + 1, ',')) {
        karmaPointsCount++;
    }

    gCustomKarmaFolderDescriptions.resize(karmaFrmsCount);

    for (int index = 0; index < karmaFrmsCount; index++) {
        char* pch;

        pch = strchr(karmaFrms, ',');
        if (pch != NULL) {
            *pch = '\0';
        }

        gCustomKarmaFolderDescriptions[index].frmId = atoi(karmaFrms);

        if (pch != NULL) {
            *pch = ',';
        }

        karmaFrms = pch + 1;

        if (index < karmaPointsCount) {
            pch = strchr(karmaPoints, ',');
            if (pch != NULL) {
                *pch = '\0';
            }

            gCustomKarmaFolderDescriptions[index].threshold = atoi(karmaPoints);

            if (pch != NULL) {
                *pch = ',';
            }

            karmaPoints = pch + 1;
        } else {
            gCustomKarmaFolderDescriptions[index].threshold = INT_MAX;
        }
    }
}

static void customKarmaFolderFree()
{
    gCustomKarmaFolderDescriptions.clear();
}

static int customKarmaFolderGetFrmId()
{
    if (gCustomKarmaFolderDescriptions.empty()) {
        return 47;
    }

    int reputation = gGameGlobalVars[GVAR_PLAYER_REPUTATION];
    for (auto& entry : gCustomKarmaFolderDescriptions) {
        if (reputation < entry.threshold) {
            return entry.frmId;
        }
    }
    return gCustomKarmaFolderDescriptions.end()->frmId;
}