fallout2-ce/src/party_member.cc

#include "party_member.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "animation.h"
#include "color.h"
#include "combat_ai.h"
#include "combat_ai_defs.h"
#include "config.h"
#include "critter.h"
#include "debug.h"
#include "display_monitor.h"
#include "game.h"
#include "game_dialog.h"
#include "item.h"
#include "loadsave.h"
#include "map.h"
#include "memory.h"
#include "message.h"
#include "object.h"
#include "proto.h"
#include "proto_instance.h"
#include "queue.h"
#include "random.h"
#include "scripts.h"
#include "skill.h"
#include "stat.h"
#include "string_parsers.h"
#include "text_object.h"
#include "tile.h"
#include "window_manager.h"

typedef struct PartyMemberDescription {
    bool areaAttackMode[AREA_ATTACK_MODE_COUNT];
    bool runAwayMode[RUN_AWAY_MODE_COUNT];
    bool bestWeapon[BEST_WEAPON_COUNT];
    bool distanceMode[DISTANCE_COUNT];
    bool attackWho[ATTACK_WHO_COUNT];
    bool chemUse[CHEM_USE_COUNT];
    bool disposition[DISPOSITION_COUNT];
    int level_minimum;
    int level_up_every;
    int level_pids_num;
    int level_pids[5];
} PartyMemberDescription;

typedef struct STRU_519DBC {
    int field_0;
    int field_4; // party member level
    int field_8; // early what?
} STRU_519DBC;

typedef struct STRUCT_519DA8 {
    Object* object;
    Script* script;
    int* vars;
    struct STRUCT_519DA8* next;
} STRUCT_519DA8;

static int partyMemberGetDescription(Object* object, PartyMemberDescription** partyMemberDescriptionPtr);
static void partyMemberDescriptionInit(PartyMemberDescription* partyMemberDescription);
static int _partyMemberPrepLoadInstance(STRUCT_519DA8* a1);
static int _partyMemberRecoverLoadInstance(STRUCT_519DA8* a1);
static int _partyMemberNewObjID();
static int _partyMemberNewObjIDRecurseFind(Object* object, int objectId);
static int _partyMemberPrepItemSave(Object* object);
static int _partyMemberItemSave(Object* object);
static int _partyMemberItemRecover(STRUCT_519DA8* a1);
static int _partyMemberClearItemList();
static int _partyFixMultipleMembers();
static int _partyMemberCopyLevelInfo(Object* object, int a2);

// 0x519D9C
int gPartyMemberDescriptionsLength = 0;

// 0x519DA0
int* gPartyMemberPids = NULL;

//
static STRUCT_519DA8* _itemSaveListHead = NULL;

// List of party members, it's length is [gPartyMemberDescriptionsLength] + 20.
//
// 0x519DA8
static STRUCT_519DA8* gPartyMembers = NULL;

// Number of critters added to party.
//
// 0x519DAC
static int gPartyMembersLength = 0;

// 0x519DB0
static int _partyMemberItemCount = 20000;

// 0x519DB4
static int _partyStatePrepped = 0;

// 0x519DB8
static PartyMemberDescription* gPartyMemberDescriptions = NULL;

// 0x519DBC
static STRU_519DBC* _partyMemberLevelUpInfoList = NULL;

// 0x519DC0
static int _curID = 20000;

// partyMember_init
// 0x493BC0
int partyMembersInit()
{
    Config config;

    gPartyMemberDescriptionsLength = 0;

    if (!configInit(&config)) {
        return -1;
    }

    if (!configRead(&config, "data\\party.txt", true)) {
        goto err;
    }

    char section[50];
    sprintf(section, "Party Member %d", gPartyMemberDescriptionsLength);

    int partyMemberPid;
    while (configGetInt(&config, section, "party_member_pid", &partyMemberPid)) {
        gPartyMemberDescriptionsLength++;
        sprintf(section, "Party Member %d", gPartyMemberDescriptionsLength);
    }

    gPartyMemberPids = (int*)internal_malloc(sizeof(*gPartyMemberPids) * gPartyMemberDescriptionsLength);
    if (gPartyMemberPids == NULL) {
        goto err;
    }

    memset(gPartyMemberPids, 0, sizeof(*gPartyMemberPids) * gPartyMemberDescriptionsLength);

    gPartyMembers = (STRUCT_519DA8*)internal_malloc(sizeof(*gPartyMembers) * (gPartyMemberDescriptionsLength + 20));
    if (gPartyMembers == NULL) {
        goto err;
    }

    memset(gPartyMembers, 0, sizeof(*gPartyMembers) * (gPartyMemberDescriptionsLength + 20));

    gPartyMemberDescriptions = (PartyMemberDescription*)internal_malloc(sizeof(*gPartyMemberDescriptions) * gPartyMemberDescriptionsLength);
    if (gPartyMemberDescriptions == NULL) {
        goto err;
    }

    memset(gPartyMemberDescriptions, 0, sizeof(*gPartyMemberDescriptions) * gPartyMemberDescriptionsLength);

    _partyMemberLevelUpInfoList = (STRU_519DBC*)internal_malloc(sizeof(*_partyMemberLevelUpInfoList) * gPartyMemberDescriptionsLength);
    if (_partyMemberLevelUpInfoList == NULL) goto err;

    memset(_partyMemberLevelUpInfoList, 0, sizeof(*_partyMemberLevelUpInfoList) * gPartyMemberDescriptionsLength);

    for (int index = 0; index < gPartyMemberDescriptionsLength; index++) {
        sprintf(section, "Party Member %d", index);

        if (!configGetInt(&config, section, "party_member_pid", &partyMemberPid)) {
            break;
        }

        PartyMemberDescription* partyMemberDescription = &(gPartyMemberDescriptions[index]);

        gPartyMemberPids[index] = partyMemberPid;

        partyMemberDescriptionInit(partyMemberDescription);

        char* string;

        if (configGetString(&config, section, "area_attack_mode", &string)) {
            while (*string != '\0') {
                int areaAttackMode;
                strParseStrFromList(&string, &areaAttackMode, gAreaAttackModeKeys, AREA_ATTACK_MODE_COUNT);
                partyMemberDescription->areaAttackMode[areaAttackMode] = true;
            }
        }

        if (configGetString(&config, section, "attack_who", &string)) {
            while (*string != '\0') {
                int attachWho;
                strParseStrFromList(&string, &attachWho, gAttackWhoKeys, ATTACK_WHO_COUNT);
                partyMemberDescription->attackWho[attachWho] = true;
            }
        }

        if (configGetString(&config, section, "best_weapon", &string)) {
            while (*string != '\0') {
                int bestWeapon;
                strParseStrFromList(&string, &bestWeapon, gBestWeaponKeys, BEST_WEAPON_COUNT);
                partyMemberDescription->bestWeapon[bestWeapon] = true;
            }
        }

        if (configGetString(&config, section, "chem_use", &string)) {
            while (*string != '\0') {
                int chemUse;
                strParseStrFromList(&string, &chemUse, gChemUseKeys, CHEM_USE_COUNT);
                partyMemberDescription->chemUse[chemUse] = true;
            }
        }

        if (configGetString(&config, section, "distance", &string)) {
            while (*string != '\0') {
                int distanceMode;
                strParseStrFromList(&string, &distanceMode, gDistanceModeKeys, DISTANCE_COUNT);
                partyMemberDescription->distanceMode[distanceMode] = true;
            }
        }

        if (configGetString(&config, section, "run_away_mode", &string)) {
            while (*string != '\0') {
                int runAwayMode;
                strParseStrFromList(&string, &runAwayMode, gRunAwayModeKeys, RUN_AWAY_MODE_COUNT);
                partyMemberDescription->runAwayMode[runAwayMode] = true;
            }
        }

        if (configGetString(&config, section, "disposition", &string)) {
            while (*string != '\0') {
                int disposition;
                strParseStrFromList(&string, &disposition, gDispositionKeys, DISPOSITION_COUNT);
                partyMemberDescription->disposition[disposition] = true;
            }
        }

        int levelUpEvery;
        if (configGetInt(&config, section, "level_up_every", &levelUpEvery)) {
            partyMemberDescription->level_up_every = levelUpEvery;

            int levelMinimum;
            if (configGetInt(&config, section, "level_minimum", &levelMinimum)) {
                partyMemberDescription->level_minimum = levelMinimum;
            }

            if (configGetString(&config, section, "level_pids", &string)) {
                while (*string != '\0' && partyMemberDescription->level_pids_num < 5) {
                    int levelPid;
                    strParseInt(&string, &levelPid);
                    partyMemberDescription->level_pids[partyMemberDescription->level_pids_num] = levelPid;
                    partyMemberDescription->level_pids_num++;
                }
            }
        }
    }

    configFree(&config);

    return 0;

err:

    configFree(&config);

    return -1;
}

// 0x4940E4
void partyMembersReset()
{
    for (int index = 0; index < gPartyMemberDescriptionsLength; index++) {
        _partyMemberLevelUpInfoList[index].field_0 = 0;
        _partyMemberLevelUpInfoList[index].field_4 = 0;
        _partyMemberLevelUpInfoList[index].field_8 = 0;
    }
}

// 0x494134
void partyMembersExit()
{
    for (int index = 0; index < gPartyMemberDescriptionsLength; index++) {
        _partyMemberLevelUpInfoList[index].field_0 = 0;
        _partyMemberLevelUpInfoList[index].field_4 = 0;
        _partyMemberLevelUpInfoList[index].field_8 = 0;
    }

    gPartyMemberDescriptionsLength = 0;

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

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

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

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

// 0x4941F0
static int partyMemberGetDescription(Object* object, PartyMemberDescription** partyMemberDescriptionPtr)
{
    for (int index = 1; index < gPartyMemberDescriptionsLength; index++) {
        if (gPartyMemberPids[index] == object->pid) {
            *partyMemberDescriptionPtr = &(gPartyMemberDescriptions[index]);
            return 0;
        }
    }

    return -1;
}

// 0x49425C
static void partyMemberDescriptionInit(PartyMemberDescription* partyMemberDescription)
{
    for (int index = 0; index < AREA_ATTACK_MODE_COUNT; index++) {
        partyMemberDescription->areaAttackMode[index] = 0;
    }

    for (int index = 0; index < RUN_AWAY_MODE_COUNT; index++) {
        partyMemberDescription->runAwayMode[index] = 0;
    }

    for (int index = 0; index < BEST_WEAPON_COUNT; index++) {
        partyMemberDescription->bestWeapon[index] = 0;
    }

    for (int index = 0; index < DISTANCE_COUNT; index++) {
        partyMemberDescription->distanceMode[index] = 0;
    }

    for (int index = 0; index < ATTACK_WHO_COUNT; index++) {
        partyMemberDescription->attackWho[index] = 0;
    }

    for (int index = 0; index < CHEM_USE_COUNT; index++) {
        partyMemberDescription->chemUse[index] = 0;
    }

    for (int index = 0; index < DISPOSITION_COUNT; index++) {
        partyMemberDescription->disposition[index] = 0;
    }

    partyMemberDescription->level_minimum = 0;
    partyMemberDescription->level_up_every = 0;
    partyMemberDescription->level_pids_num = 0;

    partyMemberDescription->level_pids[0] = -1;

    for (int index = 0; index < gPartyMemberDescriptionsLength; index++) {
        _partyMemberLevelUpInfoList[index].field_0 = 0;
        _partyMemberLevelUpInfoList[index].field_4 = 0;
        _partyMemberLevelUpInfoList[index].field_8 = 0;
    }
}

// partyMemberAdd
// 0x494378
int partyMemberAdd(Object* object)
{
    if (gPartyMembersLength >= gPartyMemberDescriptionsLength + 20) {
        return -1;
    }

    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        if (partyMember->object == object || partyMember->object->pid == object->pid) {
            return 0;
        }
    }

    if (_partyStatePrepped) {
        debugPrint("\npartyMemberAdd DENIED: %s\n", critterGetName(object));
        return -1;
    }

    STRUCT_519DA8* partyMember = &(gPartyMembers[gPartyMembersLength]);
    partyMember->object = object;
    partyMember->script = NULL;
    partyMember->vars = NULL;

    object->id = (object->pid & 0xFFFFFF) + 18000;
    object->flags |= (OBJECT_FLAG_0x400 | OBJECT_TEMPORARY);

    gPartyMembersLength++;

    Script* script;
    if (scriptGetScript(object->sid, &script) != -1) {
        script->flags |= (SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);
        script->field_1C = object->id;

        object->sid = ((object->pid & 0xFFFFFF) + 18000) | (object->sid & 0xFF000000);
        script->sid = object->sid;
    }

    critterSetTeam(object, 0);
    queueRemoveEventsByType(object, EVENT_TYPE_SCRIPT);

    if (_gdialogActive()) {
        if (object == gGameDialogSpeaker) {
            _gdialogUpdatePartyStatus();
        }
    }

    return 0;
}

// partyMemberRemove
// 0x4944DC
int partyMemberRemove(Object* object)
{
    if (gPartyMembersLength == 0) {
        return -1;
    }

    if (object == NULL) {
        return -1;
    }

    int index;
    for (index = 1; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        if (partyMember->object == object) {
            break;
        }
    }

    if (index == gPartyMembersLength) {
        return -1;
    }

    if (_partyStatePrepped) {
        debugPrint("\npartyMemberRemove DENIED: %s\n", critterGetName(object));
        return -1;
    }

    if (index < gPartyMembersLength - 1) {
        gPartyMembers[index].object = gPartyMembers[gPartyMembersLength - 1].object;
    }

    object->flags &= ~(OBJECT_FLAG_0x400 | OBJECT_TEMPORARY);

    gPartyMembersLength--;

    Script* script;
    if (scriptGetScript(object->sid, &script) != -1) {
        script->flags &= ~(SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);
    }

    queueRemoveEventsByType(object, EVENT_TYPE_SCRIPT);

    if (_gdialogActive()) {
        if (object == gGameDialogSpeaker) {
            _gdialogUpdatePartyStatus();
        }
    }

    return 0;
}

// 0x49460C
int _partyMemberPrepSave()
{
    _partyStatePrepped = 1;

    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* ptr = &(gPartyMembers[index]);

        if (index > 0) {
            ptr->object->flags &= ~(OBJECT_FLAG_0x400 | OBJECT_TEMPORARY);
        }

        Script* script;
        if (scriptGetScript(ptr->object->sid, &script) != -1) {
            script->flags &= ~(SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);
        }
    }

    return 0;
}

// 0x49466C
int _partyMemberUnPrepSave()
{
    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* ptr = &(gPartyMembers[index]);

        if (index > 0) {
            ptr->object->flags |= (OBJECT_FLAG_0x400 | OBJECT_TEMPORARY);
        }

        Script* script;
        if (scriptGetScript(ptr->object->sid, &script) != -1) {
            script->flags |= (SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);
        }
    }

    _partyStatePrepped = 0;

    return 0;
}

// 0x4946CC
int partyMembersSave(File* stream)
{
    if (fileWriteInt32(stream, gPartyMembersLength) == -1) return -1;
    if (fileWriteInt32(stream, _partyMemberItemCount) == -1) return -1;

    for (int index = 1; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        if (fileWriteInt32(stream, partyMember->object->id) == -1) return -1;
    }

    for (int index = 1; index < gPartyMemberDescriptionsLength; index++) {
        STRU_519DBC* ptr = &(_partyMemberLevelUpInfoList[index]);
        if (fileWriteInt32(stream, ptr->field_0) == -1) return -1;
        if (fileWriteInt32(stream, ptr->field_4) == -1) return -1;
        if (fileWriteInt32(stream, ptr->field_8) == -1) return -1;
    }

    return 0;
}

// 0x4947AC
int _partyMemberPrepLoad()
{
    if (_partyStatePrepped) {
        return -1;
    }

    _partyStatePrepped = 1;

    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* ptr_519DA8 = &(gPartyMembers[index]);
        if (_partyMemberPrepLoadInstance(ptr_519DA8) != 0) {
            return -1;
        }
    }

    return 0;
}

// partyMemberPrepLoadInstance
// 0x49480C
static int _partyMemberPrepLoadInstance(STRUCT_519DA8* a1)
{
    Object* obj = a1->object;

    if (obj == NULL) {
        debugPrint("\n  Error!: partyMemberPrepLoadInstance: No Critter Object!");
        a1->script = NULL;
        a1->vars = NULL;
        a1->next = NULL;
        return 0;
    }

    if (PID_TYPE(obj->pid) == OBJ_TYPE_CRITTER) {
        obj->data.critter.combat.whoHitMe = NULL;
    }

    Script* script;
    if (scriptGetScript(obj->sid, &script) == -1) {
        debugPrint("\n  Error!: partyMemberPrepLoadInstance: Can't find script!");
        debugPrint("\n          partyMemberPrepLoadInstance: script was: (%s)", critterGetName(obj));
        a1->script = NULL;
        a1->vars = NULL;
        a1->next = NULL;
        return 0;
    }

    a1->script = (Script*)internal_malloc(sizeof(*script));
    if (a1->script == NULL) {
        showMesageBox("\n  Error!: partyMemberPrepLoad: Out of memory!");
        exit(1);
    }

    memcpy(a1->script, script, sizeof(*script));

    if (script->localVarsCount != 0 && script->localVarsOffset != -1) {
        a1->vars = (int*)internal_malloc(sizeof(*a1->vars) * script->localVarsCount);
        if (a1->vars == NULL) {
            showMesageBox("\n  Error!: partyMemberPrepLoad: Out of memory!");
            exit(1);
        }

        if (gMapLocalVars != NULL) {
            memcpy(a1->vars, gMapLocalVars + script->localVarsOffset, sizeof(int) * script->localVarsCount);
        } else {
            debugPrint("\nWarning: partyMemberPrepLoadInstance: No map_local_vars found, but script references them!");
            memset(a1->vars, 0, sizeof(int) * script->localVarsCount);
        }
    }

    Inventory* inventory = &(obj->data.inventory);
    for (int index = 0; index < inventory->length; index++) {
        InventoryItem* inventoryItem = &(inventory->items[index]);
        _partyMemberItemSave(inventoryItem->item);
    }

    script->flags &= ~(SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);

    scriptRemove(script->sid);

    if (PID_TYPE(obj->pid) == OBJ_TYPE_CRITTER) {
        _dude_stand(obj, obj->rotation, -1);
    }

    return 0;
}

// partyMemberRecoverLoad
// 0x4949C4
int _partyMemberRecoverLoad()
{
    if (_partyStatePrepped != 1) {
        debugPrint("\npartyMemberRecoverLoad DENIED");
        return -1;
    }

    debugPrint("\n");

    for (int index = 0; index < gPartyMembersLength; index++) {
        if (_partyMemberRecoverLoadInstance(&(gPartyMembers[index])) != 0) {
            return -1;
        }

        debugPrint("[Party Member %d]: %s\n", index, critterGetName(gPartyMembers[index].object));
    }

    STRUCT_519DA8* v6 = _itemSaveListHead;
    while (v6 != NULL) {
        _itemSaveListHead = v6->next;

        _partyMemberItemRecover(v6);
        internal_free(v6);

        v6 = _itemSaveListHead;
    }

    _partyStatePrepped = 0;

    if (!_isLoadingGame()) {
        _partyFixMultipleMembers();
    }

    return 0;
}

// partyMemberRecoverLoadInstance
// 0x494A88
static int _partyMemberRecoverLoadInstance(STRUCT_519DA8* a1)
{
    if (a1->script == NULL) {
        showMesageBox("\n  Error!: partyMemberRecoverLoadInstance: No script!");
        return 0;
    }

    int scriptType = SCRIPT_TYPE_CRITTER;
    if (PID_TYPE(a1->object->pid) != OBJ_TYPE_CRITTER) {
        scriptType = SCRIPT_TYPE_ITEM;
    }

    int v1 = -1;
    if (scriptAdd(&v1, scriptType) == -1) {
        showMesageBox("\n  Error!: partyMemberRecoverLoad: Can't create script!");
        exit(1);
    }

    Script* script;
    if (scriptGetScript(v1, &script) == -1) {
        showMesageBox("\n  Error!: partyMemberRecoverLoad: Can't find script!");
        exit(1);
    }

    memcpy(script, a1->script, sizeof(*script));

    int sid = (scriptType << 24) | ((a1->object->pid & 0xFFFFFF) + 18000);
    a1->object->sid = sid;
    script->sid = sid;

    script->flags &= ~(SCRIPT_FLAG_0x01 | SCRIPT_FLAG_0x04);

    internal_free(a1->script);
    a1->script = NULL;

    script->flags |= (SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);

    if (a1->vars != NULL) {
        script->localVarsOffset = _map_malloc_local_var(script->localVarsCount);
        memcpy(gMapLocalVars + script->localVarsOffset, a1->vars, sizeof(int) * script->localVarsCount);
    }

    return 0;
}

// 0x494BBC
int partyMembersLoad(File* stream)
{
    int* partyMemberObjectIds = (int*)internal_malloc(sizeof(*partyMemberObjectIds) * (gPartyMemberDescriptionsLength + 20));
    if (partyMemberObjectIds == NULL) {
        return -1;
    }

    // FIXME: partyMemberObjectIds is never free'd in this function, obviously memory leak.

    if (fileReadInt32(stream, &gPartyMembersLength) == -1) return -1;
    if (fileReadInt32(stream, &_partyMemberItemCount) == -1) return -1;

    gPartyMembers->object = gDude;

    if (gPartyMembersLength != 0) {
        for (int index = 1; index < gPartyMembersLength; index++) {
            if (fileReadInt32(stream, &(partyMemberObjectIds[index])) == -1) return -1;
        }

        for (int index = 1; index < gPartyMembersLength; index++) {
            int objectId = partyMemberObjectIds[index];

            Object* object = objectFindFirst();
            while (object != NULL) {
                if (object->id == objectId) {
                    break;
                }
                object = objectFindNext();
            }

            if (object != NULL) {
                gPartyMembers[index].object = object;
            } else {
                debugPrint("Couldn't find party member on map...trying to load anyway.\n");
                if (index + 1 >= gPartyMembersLength) {
                    partyMemberObjectIds[index] = 0;
                } else {
                    memcpy(&(partyMemberObjectIds[index]), &(partyMemberObjectIds[index + 1]), sizeof(*partyMemberObjectIds) * (gPartyMembersLength - (index + 1)));
                }

                index--;
                gPartyMembersLength--;
            }
        }

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

    _partyFixMultipleMembers();

    for (int index = 1; index < gPartyMemberDescriptionsLength; index++) {
        STRU_519DBC* ptr_519DBC = &(_partyMemberLevelUpInfoList[index]);

        if (fileReadInt32(stream, &(ptr_519DBC->field_0)) == -1) return -1;
        if (fileReadInt32(stream, &(ptr_519DBC->field_4)) == -1) return -1;
        if (fileReadInt32(stream, &(ptr_519DBC->field_8)) == -1) return -1;
    }

    return 0;
}

// 0x494D7C
void _partyMemberClear()
{
    if (_partyStatePrepped) {
        _partyMemberUnPrepSave();
    }

    for (int index = gPartyMembersLength; index > 1; index--) {
        partyMemberRemove(gPartyMembers[1].object);
    }

    gPartyMembersLength = 1;

    _scr_remove_all();
    _partyMemberClearItemList();

    _partyStatePrepped = 0;
}

// 0x494DD0
int _partyMemberSyncPosition()
{
    int clockwiseRotation = (gDude->rotation + 2) % ROTATION_COUNT;
    int counterClockwiseRotation = (gDude->rotation + 4) % ROTATION_COUNT;

    int n = 0;
    int distance = 2;
    for (int index = 1; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        Object* partyMemberObj = partyMember->object;
        if ((partyMemberObj->flags & OBJECT_HIDDEN) == 0 && PID_TYPE(partyMemberObj->pid) == OBJ_TYPE_CRITTER) {
            int rotation;
            if ((n % 2) != 0) {
                rotation = clockwiseRotation;
            } else {
                rotation = counterClockwiseRotation;
            }

            int tile = tileGetTileInDirection(gDude->tile, rotation, distance / 2);
            _objPMAttemptPlacement(partyMemberObj, tile, gDude->elevation);

            distance++;
            n++;
        }
    }

    return 0;
}

// Heals party members according to their healing rate.
//
// 0x494EB8
int _partyMemberRestingHeal(int a1)
{
    int v1 = a1 / 3;
    if (v1 == 0) {
        return 0;
    }

    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        if (PID_TYPE(partyMember->object->pid) == OBJ_TYPE_CRITTER) {
            int healingRate = critterGetStat(partyMember->object, STAT_HEALING_RATE);
            critterAdjustHitPoints(partyMember->object, v1 * healingRate);
        }
    }

    return 1;
}

// 0x494F24
Object* partyMemberFindByPid(int pid)
{
    for (int index = 0; index < gPartyMembersLength; index++) {
        Object* object = gPartyMembers[index].object;
        if (object->pid == pid) {
            return object;
        }
    }

    return NULL;
}

// 0x494F64
bool _isPotentialPartyMember(Object* object)
{
    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);
        if (partyMember->object->pid == gPartyMemberPids[index]) {
            return true;
        }
    }

    return false;
}

// Returns `true` if specified object is a party member.
//
// 0x494FC4
bool objectIsPartyMember(Object* object)
{
    if (object == NULL) {
        return false;
    }

    if (object->id < 18000) {
        return false;
    }

    bool isPartyMember = false;

    for (int index = 0; index < gPartyMembersLength; index++) {
        if (gPartyMembers[index].object == object) {
            isPartyMember = true;
            break;
        }
    }

    return isPartyMember;
}

// Returns number of active critters in the party.
//
// 0x495010
int _getPartyMemberCount()
{
    int count = gPartyMembersLength;

    for (int index = 1; index < gPartyMembersLength; index++) {
        Object* object = gPartyMembers[index].object;

        if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER || critterIsDead(object) || (object->flags & OBJECT_HIDDEN) != 0) {
            count--;
        }
    }

    return count;
}

// 0x495070
static int _partyMemberNewObjID()
{
    Object* object;

    do {
        _curID++;

        object = objectFindFirst();
        while (object != NULL) {
            if (object->id == _curID) {
                break;
            }

            Inventory* inventory = &(object->data.inventory);

            int index;
            for (index = 0; index < inventory->length; index++) {
                InventoryItem* inventoryItem = &(inventory->items[index]);
                Object* item = inventoryItem->item;
                if (item->id == _curID) {
                    break;
                }

                if (_partyMemberNewObjIDRecurseFind(item, _curID)) {
                    break;
                }
            }

            if (index < inventory->length) {
                break;
            }

            object = objectFindNext();
        }
    } while (object != NULL);

    _curID++;

    return _curID;
}

// 0x4950F4
static int _partyMemberNewObjIDRecurseFind(Object* obj, int objectId)
{
    Inventory* inventory = &(obj->data.inventory);
    for (int index = 0; index < inventory->length; index++) {
        InventoryItem* inventoryItem = &(inventory->items[index]);
        if (inventoryItem->item->id == objectId) {
            return 1;
        }

        if (_partyMemberNewObjIDRecurseFind(inventoryItem->item, objectId)) {
            return 1;
        }
    }

    return 0;
}

// 0x495140
int _partyMemberPrepItemSaveAll()
{
    for (int partyMemberIndex = 0; partyMemberIndex < gPartyMembersLength; partyMemberIndex++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[partyMemberIndex]);

        Inventory* inventory = &(partyMember->object->data.inventory);
        for (int inventoryItemIndex = 0; inventoryItemIndex < inventory->length; inventoryItemIndex++) {
            InventoryItem* inventoryItem = &(inventory->items[inventoryItemIndex]);
            _partyMemberPrepItemSave(inventoryItem->item);
        }
    }

    return 0;
}

// partyMemberPrepItemSaveAll
static int _partyMemberPrepItemSave(Object* object)
{
    if (object->sid != -1) {
        Script* script;
        if (scriptGetScript(object->sid, &script) == -1) {
            showMesageBox("\n  Error!: partyMemberPrepItemSaveAll: Can't find script!");
            exit(1);
        }

        script->flags |= (SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);
    }

    Inventory* inventory = &(object->data.inventory);
    for (int index = 0; index < inventory->length; index++) {
        InventoryItem* inventoryItem = &(inventory->items[index]);
        _partyMemberPrepItemSave(inventoryItem->item);
    }

    return 0;
}

// 0x495234
static int _partyMemberItemSave(Object* object)
{
    if (object->sid != -1) {
        Script* script;
        if (scriptGetScript(object->sid, &script) == -1) {
            showMesageBox("\n  Error!: partyMemberItemSave: Can't find script!");
            exit(1);
        }

        if (object->id < 20000) {
            script->field_1C = _partyMemberNewObjID();
            object->id = script->field_1C;
        }

        STRUCT_519DA8* node = (STRUCT_519DA8*)internal_malloc(sizeof(*node));
        if (node == NULL) {
            showMesageBox("\n  Error!: partyMemberItemSave: Out of memory!");
            exit(1);
        }

        node->object = object;

        node->script = (Script*)internal_malloc(sizeof(*script));
        if (node->script == NULL) {
            showMesageBox("\n  Error!: partyMemberItemSave: Out of memory!");
            exit(1);
        }

        memcpy(node->script, script, sizeof(*script));

        if (script->localVarsCount != 0 && script->localVarsOffset != -1) {
            node->vars = (int*)internal_malloc(sizeof(*node->vars) * script->localVarsCount);
            if (node->vars == NULL) {
                showMesageBox("\n  Error!: partyMemberItemSave: Out of memory!");
                exit(1);
            }

            memcpy(node->vars, gMapLocalVars + script->localVarsOffset, sizeof(int) * script->localVarsCount);
        } else {
            node->vars = NULL;
        }

        STRUCT_519DA8* temp = _itemSaveListHead;
        _itemSaveListHead = node;
        node->next = temp;
    }

    Inventory* inventory = &(object->data.inventory);
    for (int index = 0; index < inventory->length; index++) {
        InventoryItem* inventoryItem = &(inventory->items[index]);
        _partyMemberItemSave(inventoryItem->item);
    }

    return 0;
}

// partyMemberItemRecover
// 0x495388
static int _partyMemberItemRecover(STRUCT_519DA8* a1)
{
    int sid = -1;
    if (scriptAdd(&sid, SCRIPT_TYPE_ITEM) == -1) {
        showMesageBox("\n  Error!: partyMemberItemRecover: Can't create script!");
        exit(1);
    }

    Script* script;
    if (scriptGetScript(sid, &script) == -1) {
        showMesageBox("\n  Error!: partyMemberItemRecover: Can't find script!");
        exit(1);
    }

    memcpy(script, a1->script, sizeof(*script));

    a1->object->sid = _partyMemberItemCount | (SCRIPT_TYPE_ITEM << 24);
    script->sid = _partyMemberItemCount | (SCRIPT_TYPE_ITEM << 24);

    script->program = NULL;
    script->flags &= ~(SCRIPT_FLAG_0x01 | SCRIPT_FLAG_0x04 | SCRIPT_FLAG_0x08 | SCRIPT_FLAG_0x10);

    _partyMemberItemCount++;

    internal_free(a1->script);
    a1->script = NULL;

    if (a1->vars != NULL) {
        script->localVarsOffset = _map_malloc_local_var(script->localVarsCount);
        memcpy(gMapLocalVars + script->localVarsOffset, a1->vars, sizeof(int) * script->localVarsCount);
    }

    return 0;
}

// 0x4954C4
static int _partyMemberClearItemList()
{
    while (_itemSaveListHead != NULL) {
        STRUCT_519DA8* node = _itemSaveListHead;
        _itemSaveListHead = _itemSaveListHead->next;

        if (node->script != NULL) {
            internal_free(node->script);
        }

        if (node->vars != NULL) {
            internal_free(node->vars);
        }

        internal_free(node);
    }

    _partyMemberItemCount = 20000;

    return 0;
}

// Returns best skill of the specified party member.
//
// 0x495520
int partyMemberGetBestSkill(Object* object)
{
    int bestSkill = SKILL_SMALL_GUNS;

    if (object == NULL) {
        return bestSkill;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return bestSkill;
    }

    int bestValue = 0;
    for (int skill = 0; skill < SKILL_COUNT; skill++) {
        int value = skillGetValue(object, skill);
        if (value > bestValue) {
            bestSkill = skill;
            bestValue = value;
        }
    }

    return bestSkill;
}

// Returns party member with highest skill level.
//
// 0x495560
Object* partyMemberGetBestInSkill(int skill)
{
    int bestValue = 0;
    Object* bestPartyMember = NULL;

    for (int index = 0; index < gPartyMembersLength; index++) {
        Object* object = gPartyMembers[index].object;
        if ((object->flags & OBJECT_HIDDEN) == 0 && PID_TYPE(object->pid) == OBJ_TYPE_CRITTER) {
            int value = skillGetValue(object, skill);
            if (value > bestValue) {
                bestValue = value;
                bestPartyMember = object;
            }
        }
    }

    return bestPartyMember;
}

// Returns highest skill level in party.
//
// 0x4955C8
int partyGetBestSkillValue(int skill)
{
    int bestValue = 0;

    for (int index = 0; index < gPartyMembersLength; index++) {
        Object* object = gPartyMembers[index].object;
        if ((object->flags & OBJECT_HIDDEN) == 0 && PID_TYPE(object->pid) == OBJ_TYPE_CRITTER) {
            int value = skillGetValue(object, skill);
            if (value > bestValue) {
                bestValue = value;
            }
        }
    }

    return bestValue;
}

// 0x495620
static int _partyFixMultipleMembers()
{
    debugPrint("\n\n\n[Party Members]:");

    int critterCount = 0;
    for (Object* obj = objectFindFirst(); obj != NULL; obj = objectFindNext()) {
        if (PID_TYPE(obj->pid) == OBJ_TYPE_CRITTER) {
            critterCount++;
        }

        bool isPartyMember = false;
        for (int index = 1; index < gPartyMemberDescriptionsLength; index++) {
            if (obj->pid == gPartyMemberPids[index]) {
                isPartyMember = true;
                break;
            }
        }

        if (!isPartyMember) {
            continue;
        }

        debugPrint("\n   PM: %s", critterGetName(obj));

        bool v19 = false;
        if (obj->sid == -1) {
            v19 = true;
        } else {
            Object* v7 = NULL;
            for (int i = 0; i < gPartyMembersLength; i++) {
                if (obj->pid == gPartyMembers[i].object->pid) {
                    v7 = gPartyMembers[i].object;
                    break;
                }
            }

            if (v7 != NULL && obj != v7) {
                if (v7->sid == obj->sid) {
                    obj->sid = -1;
                }
                v19 = true;
            }
        }

        if (!v19) {
            continue;
        }

        Object* v10 = NULL;
        for (int i = 0; i < gPartyMembersLength; i++) {
            if (obj->pid == gPartyMembers[i].object->pid) {
                v10 = gPartyMembers[i].object;
            }
        }

        // TODO: Probably wrong.
        if (obj == v10) {
            debugPrint("\nError: Attempting to destroy evil critter doppleganger FAILED!");
            continue;
        }

        debugPrint("\nDestroying evil critter doppleganger!");

        if (obj->sid != -1) {
            scriptRemove(obj->sid);
            obj->sid = -1;
        } else {
            if (queueRemoveEventsByType(obj, EVENT_TYPE_SCRIPT) == -1) {
                debugPrint("\nERROR Removing Timed Events on FIX remove!!\n");
            }
        }

        objectDestroy(obj, NULL);
    }

    for (int index = 0; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* partyMember = &(gPartyMembers[index]);

        Script* script;
        if (scriptGetScript(partyMember->object->sid, &script) != -1) {
            script->owner = partyMember->object;
        } else {
            debugPrint("\nError: Failed to fix party member critter scripts!");
        }
    }

    debugPrint("\nTotal Critter Count: %d\n\n", critterCount);

    return 0;
}

// 0x495870
void _partyMemberSaveProtos()
{
    for (int index = 1; index < gPartyMemberDescriptionsLength; index++) {
        int pid = gPartyMemberPids[index];
        if (pid != -1) {
            _proto_save_pid(pid);
        }
    }
}

// 0x4958B0
bool partyMemberSupportsDisposition(Object* critter, int disposition)
{
    if (critter == NULL) {
        return false;
    }

    if (PID_TYPE(critter->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (disposition == -1 || disposition > 5) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(critter, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->disposition[disposition + 1];
}

// 0x495920
bool partyMemberSupportsAreaAttackMode(Object* object, int areaAttackMode)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (areaAttackMode >= AREA_ATTACK_MODE_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->areaAttackMode[areaAttackMode];
}

// 0x495980
bool partyMemberSupportsRunAwayMode(Object* object, int runAwayMode)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (runAwayMode >= RUN_AWAY_MODE_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->runAwayMode[runAwayMode + 1];
}

// 0x4959E0
bool partyMemberSupportsBestWeapon(Object* object, int bestWeapon)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (bestWeapon >= BEST_WEAPON_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->bestWeapon[bestWeapon];
}

// 0x495A40
bool partyMemberSupportsDistance(Object* object, int distanceMode)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (distanceMode >= DISTANCE_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->distanceMode[distanceMode];
}

// 0x495AA0
bool partyMemberSupportsAttackWho(Object* object, int attackWho)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (attackWho >= ATTACK_WHO_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->attackWho[attackWho];
}

// 0x495B00
bool partyMemberSupportsChemUse(Object* object, int chemUse)
{
    if (object == NULL) {
        return false;
    }

    if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) {
        return false;
    }

    if (chemUse >= CHEM_USE_COUNT) {
        return false;
    }

    PartyMemberDescription* partyMemberDescription;
    if (partyMemberGetDescription(object, &partyMemberDescription) == -1) {
        return false;
    }

    return partyMemberDescription->chemUse[chemUse];
}

// partyMemberIncLevels
// 0x495B60
int _partyMemberIncLevels()
{
    int i;
    STRUCT_519DA8* ptr;
    Object* obj;
    PartyMemberDescription* party_member;
    const char* name;
    int j;
    int v0;
    STRU_519DBC* ptr_519DBC;
    int v24;
    char* text;
    MessageListItem msg;
    char str[260];
    Rect v19;

    v0 = -1;
    for (i = 1; i < gPartyMembersLength; i++) {
        ptr = &(gPartyMembers[i]);
        obj = ptr->object;

        if (partyMemberGetDescription(obj, &party_member) == -1) {
            break;
        }

        if (PID_TYPE(obj->pid) != OBJ_TYPE_CRITTER) {
            continue;
        }

        name = critterGetName(obj);
        debugPrint("\npartyMemberIncLevels: %s", name);

        if (party_member->level_up_every == 0) {
            continue;
        }

        for (j = 1; j < gPartyMemberDescriptionsLength; j++) {
            if (gPartyMemberPids[j] == obj->pid) {
                v0 = j;
            }
        }

        if (v0 == -1) {
            continue;
        }

        if (pcGetStat(PC_STAT_LEVEL) < party_member->level_minimum) {
            continue;
        }

        ptr_519DBC = &(_partyMemberLevelUpInfoList[v0]);

        if (ptr_519DBC->field_0 >= party_member->level_pids_num) {
            continue;
        }

        ptr_519DBC->field_4++;

        v24 = ptr_519DBC->field_4 % party_member->level_pids_num;
        debugPrint("pm: levelMod: %d, Lvl: %d, Early: %d, Every: %d", v24, ptr_519DBC->field_4, ptr_519DBC->field_8, party_member->level_up_every);

        if (v24 != 0 || ptr_519DBC->field_8 == 0) {
            if (ptr_519DBC->field_8 == 0) {
                if (v24 == 0 || randomBetween(0, 100) <= 100 * v24 / party_member->level_up_every) {
                    ptr_519DBC->field_0++;
                    if (v24 != 0) {
                        ptr_519DBC->field_8 = 1;
                    }

                    if (_partyMemberCopyLevelInfo(obj, party_member->level_pids[ptr_519DBC->field_0]) == -1) {
                        return -1;
                    }

                    name = critterGetName(obj);
                    // %s has gained in some abilities.
                    text = getmsg(&gMiscMessageList, &msg, 9000);
                    sprintf(str, text, name);
                    displayMonitorAddMessage(str);

                    debugPrint(str);

                    // Individual message
                    msg.num = 9000 + 10 * v0 + ptr_519DBC->field_0 - 1;
                    if (messageListGetItem(&gMiscMessageList, &msg)) {
                        name = critterGetName(obj);
                        sprintf(str, msg.text, name);
                        textObjectAdd(obj, str, 101, _colorTable[0x7FFF], _colorTable[0], &v19);
                        tileWindowRefreshRect(&v19, obj->elevation);
                    }
                }
            }
        } else {
            ptr_519DBC->field_8 = 0;
        }
    }

    return 0;
}

// 0x495EA8
static int _partyMemberCopyLevelInfo(Object* critter, int a2)
{
    if (critter == NULL) {
        return -1;
    }

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

    Proto* proto1;
    if (protoGetProto(critter->pid, &proto1) == -1) {
        return -1;
    }

    Proto* proto2;
    if (protoGetProto(a2, &proto2) == -1) {
        return -1;
    }

    Object* item2 = critterGetItem2(critter);
    _invenUnwieldFunc(critter, 1, 0);

    Object* armor = critterGetArmor(critter);
    _adjust_ac(critter, armor, NULL);
    itemRemove(critter, armor, 1);

    int maxHp = critterGetStat(critter, STAT_MAXIMUM_HIT_POINTS);
    critterAdjustHitPoints(critter, maxHp);

    for (int stat = 0; stat < SPECIAL_STAT_COUNT; stat++) {
        proto1->critter.data.baseStats[stat] = proto2->critter.data.baseStats[stat];
    }

    for (int stat = 0; stat < SPECIAL_STAT_COUNT; stat++) {
        proto1->critter.data.bonusStats[stat] = proto2->critter.data.bonusStats[stat];
    }

    for (int skill = 0; skill < SKILL_COUNT; skill++) {
        proto1->critter.data.skills[skill] = proto2->critter.data.skills[skill];
    }

    critter->data.critter.hp = critterGetStat(critter, STAT_MAXIMUM_HIT_POINTS);

    if (armor != NULL) {
        itemAdd(critter, armor, 1);
        _inven_wield(critter, armor, 0);
    }

    if (item2 != NULL) {
        // SFALL: Fix for party member's equipped weapon being placed in the
        // incorrect item slot after leveling up.
        _invenWieldFunc(critter, item2, 1, false);
    }

    return 0;
}

// Returns `true` if any party member that can be healed thru the rest is
// wounded.
//
// This function is used to determine if any party member needs healing thru
// the "Rest until party healed", therefore it excludes robots in the party
// (they cannot be healed by resting) and dude (he/she has it's own "Rest
// until healed" option).
//
// 0x496058
bool partyIsAnyoneCanBeHealedByRest()
{
    for (int index = 1; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* ptr = &(gPartyMembers[index]);
        Object* object = ptr->object;

        if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) continue;
        if (critterIsDead(object)) continue;
        if ((object->flags & OBJECT_HIDDEN) != 0) continue;
        if (critterGetKillType(object) == KILL_TYPE_ROBOT) continue;

        int currentHp = critterGetHitPoints(object);
        int maximumHp = critterGetStat(object, STAT_MAXIMUM_HIT_POINTS);
        if (currentHp < maximumHp) {
            return true;
        }
    }

    return false;
}

// Returns maximum amount of damage of any party member that can be healed thru
// the rest.
//
// 0x4960DC
int partyGetMaxWoundToHealByRest()
{
    int maxWound = 0;

    for (int index = 1; index < gPartyMembersLength; index++) {
        STRUCT_519DA8* ptr = &(gPartyMembers[index]);
        Object* object = ptr->object;

        if (PID_TYPE(object->pid) != OBJ_TYPE_CRITTER) continue;
        if (critterIsDead(object)) continue;
        if ((object->flags & OBJECT_HIDDEN) != 0) continue;
        if (critterGetKillType(object) == KILL_TYPE_ROBOT) continue;

        int currentHp = critterGetHitPoints(object);
        int maximumHp = critterGetStat(object, STAT_MAXIMUM_HIT_POINTS);
        int wound = maximumHp - currentHp;
        if (wound > 0) {
            if (wound > maxWound) {
                maxWound = wound;
            }
        }
    }

    return maxWound;
}