dfhack/tools/playground/fix-3708.cpp

/* Fixes bug 3708 (Ghosts that can't be engraved on a slab).

   Cause of the bug:

      In order to be engraved on a slab, the creature must be
    a historical figure, i.e. be in the historical figure list
    of the Legends mode. It seems that caravan guards are not
    added to that list until they do something notable, e.g.
    kill a goblin. Unfortunately, their own death doesn't
    trigger this sometimes.

   Solution:

      Steal a historical figure entry from a dead goblin, by
    replacing the IDs in the structures; also overwrite his
    name, race and profession to make the menus make slightly
    more sense.

   Downsides:

    - Obviously, this is an ugly hack.
    - The Legends mode still lists the guard as belonging to
      the goblin civilization, and killed by whoever killed the
      original goblin. There might be other inconsistencies.

   Positive sides:

    - Avoids messing with tricky creature control code,
      by allowing the ghost to be removed naturally.
 */

#include <iostream>
#include <climits>
#include <string.h>
#include <vector>
#include <list>
#include <stdio.h>
using namespace std;

#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>

enum likeType
{
    FAIL = 0,
    MATERIAL = 1,
    ITEM = 2,
    FOOD = 3
};

DFHack::Materials * Materials;
DFHack::VersionInfo *mem;
DFHack::Creatures * Creatures = NULL;

void printCreature(DFHack::Context * DF, const DFHack::t_creature & creature)
{
    cout << "Address: " << hex <<  creature.origin << dec << ", creature race: " << Materials->raceEx[creature.race].rawname
         << ", position: " << creature.x << "x " << creature.y << "y "<< creature.z << "z" << endl
         << "Name: " << creature.name.first_name;

    if (creature.name.nickname[0])
        cout << " `" << creature.name.nickname << "'";

    DFHack::Translation * Tran = DF->getTranslation();

    cout << " " << Tran->TranslateName(creature.name,false)
         << " (" << Tran->TranslateName(creature.name,true) << ")" << endl;

    cout << "Profession: " << mem->getProfession(creature.profession);

    if(creature.custom_profession[0])
        cout << ", custom: " << creature.custom_profession;

    uint32_t dayoflife = creature.birth_year*12*28 + creature.birth_time/1200;
    cout << endl
         << "Born on the year " << creature.birth_year
         << ", month " << (creature.birth_time/1200/28)
         << ", day " << ((creature.birth_time/1200) % 28 + 1)
         << ", " << dayoflife << " days lived." << endl << endl;
}


int main (int numargs, char ** args)
{
    DFHack::World * World;
    DFHack::ContextManager DFMgr("Memory.xml");
    DFHack::Context* DF;
    try
    {
        DF = DFMgr.getSingleContext();
        DF->Attach();
    }
    catch (exception& e)
    {
        cerr << e.what() << endl;
        #ifndef LINUX_BUILD
            cin.ignore();
        #endif
        return 1;
    }

    Creatures = DF->getCreatures();
    Materials = DF->getMaterials();
    World = DF->getWorld();
    DFHack::Translation * Tran = DF->getTranslation();

    uint32_t numCreatures;
    if(!Creatures->Start(numCreatures))
    {
        cerr << "Can't get creatures" << endl;
        #ifndef LINUX_BUILD
            cin.ignore();
        #endif
        return 1;
    }

    Materials->ReadCreatureTypes();
    Materials->ReadCreatureTypesEx();

    mem = DF->getMemoryInfo();
    DFHack::Process *p = DF->getProcess();

    if(!Tran->Start())
    {
        cerr << "Can't get name tables" << endl;
        return 1;
    }

    DFHack::OffsetGroup *ogc = mem->getGroup("Creatures")->getGroup("creature");
    uint32_t o_flags3 = ogc->getOffset("flags3");
    uint32_t o_c_hfid = ogc->getGroup("advanced")->getOffset("hist_figure_id");

    std::list<uint32_t> goblins;
    std::list<uint32_t> ghosts;

    for(uint32_t i = 0; i < numCreatures; i++)
    {
        DFHack::t_creature temp;
        Creatures->ReadCreature(i,temp);

        int32_t hfid = p->readDWord(temp.origin + o_c_hfid);

        if (hfid > 0) {
            if (temp.flags1.bits.dead) {
                std::string name = Materials->raceEx[temp.race].rawname;
                if (name == "GOBLIN")
                    goblins.push_back(i);
            }
        } else {
            uint32_t flags3 = p->readDWord(temp.origin + o_flags3);
            if (!(flags3 & 0x1000))
                continue;

            ghosts.push_back(i);
        }
    }

    if (goblins.size() >= ghosts.size() && ghosts.size() > 0)
    {
        DFHack::OffsetGroup *grp_figures = mem->getGroup("Legends")->getGroup("figures");
        uint32_t f_vector = p->readDWord(grp_figures->getAddress("vector"));
        uint32_t f_id = grp_figures->getOffset("figure_id");
        uint32_t f_unit = grp_figures->getOffset("unit_id");
        uint32_t f_name = grp_figures->getOffset("name");
        uint32_t f_race = grp_figures->getOffset("race");
        uint32_t f_profession = grp_figures->getOffset("profession");

        for (std::list<uint32_t>::iterator it = ghosts.begin(); it != ghosts.end(); ++it)
        {
            int i = *it;
            DFHack::t_creature ghost;
            Creatures->ReadCreature(i,ghost);

            printCreature(DF,ghost);

            int igoblin = goblins.front();
            goblins.pop_front();
            DFHack::t_creature goblin;
            Creatures->ReadCreature(igoblin,goblin);

            printCreature(DF,goblin);

            int32_t hfid = p->readDWord(goblin.origin + o_c_hfid);
            uint32_t fptr = p->readDWord(f_vector + 4*hfid);

            if (p->readDWord(fptr + f_id) != hfid ||
                p->readDWord(fptr + f_unit) != goblin.id ||
                p->readWord(fptr + f_race) != goblin.race)
            {
                cout << "Data structure inconsistency detected, aborting.";
                break;
            }

            if (1) {
                p->writeDWord(goblin.origin + o_c_hfid, -1);
                p->writeDWord(ghost.origin + o_c_hfid, hfid);
                p->writeDWord(fptr + f_unit, ghost.id);
                p->writeWord(fptr + f_race, ghost.race);
                p->writeWord(fptr + f_profession, ghost.profession);
                Creatures->CopyNameTo(ghost, fptr + f_name);
                cout << "Pair succesfully patched." << endl << endl;
            }
        }
    }
    else
    {
        cout << "No suitable ghosts, or not enough goblins." << endl;
    }

    Creatures->Finish();
    DF->Detach();
    #ifndef LINUX_BUILD
    cout << "Done. Press any key to continue" << endl;
    cin.ignore();
    #endif
    return 0;
}