MetzNet
/
dfhack
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of pointless old code

develop
Petr Mrázek 2012-02-29 23:58:52 +01:00
parent c0164c02bd
commit 1f2782d5b8
25 changed files with 0 additions and 4597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
tools/examples/CMakeLists.txt
Unescape Escape View File

@ -1,43 +0,0 @@
if(NOT DEFINED DFHACK_CONSISTENCY)
MESSAGE(FATAL_ERROR "Please build the whole thing, not parts. You can turn parts on/off using options.")
ENDIF()
# this is required to ensure we use the right configuration for the system.
IF(UNIX)
add_definitions(-DLINUX_BUILD)
ENDIF(UNIX)
# buildingsdump - dump buildings and their raw data filtered by type
DFHACK_TOOL(dfbuildingsdump buildingsdump.cpp)
# constructiondump - dump engravings!
DFHACK_TOOL(dfengravingdump engravingdump.cpp)
# constructiondump - dump constructions!
DFHACK_TOOL(dfconstructiondump construction_dump.cpp)
# creaturedump - basic creature dump - a test of the creature related exports
DFHACK_TOOL(dfcreaturedump creaturedump.cpp)
# materialtest - just list the first material of each type
DFHACK_TOOL(dfmaterialtest materialtest.cpp)
# itemdump - dump the item under the cursor
DFHACK_TOOL(dfitemdump dfitemdump.cpp)
# hotkeynotedump - dumps the hotkeys and notes for the loaded map
# Author: belal
DFHACK_TOOL(dfhotkeynotedump hotkeynotedump.cpp)
# settlementdump - dumps the settlements on the loaded map
# Author: belal
# DFHACK_TOOL(dfsettlementdump settlementdump.cpp)
# treedump - dump them trees!
DFHACK_TOOL(dftreedump treedump.cpp)
# spatterdump - dump spatter 'veins'
DFHACK_TOOL(dfspatterdump spatterdump.cpp)
# processenum - demonstrates the use of ProcessEnumerator
DFHACK_TOOL(dfprocessenum processenum.cpp)

179
tools/examples/buildingsdump.cpp
Unescape Escape View File

@ -1,179 +0,0 @@
// Building dump
#include <iostream>
#include <iomanip>
#include <sstream>
#include <climits>
#include <vector>
#include <stdio.h>
//using namespace std;
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
void doWordPerLine(DFHack::Context *DF, DFHack::VersionInfo * mem,
DFHack::Buildings * Bld, uint32_t numBuildings,
const char* type, int lines)
{
std::cout << numBuildings << std::endl;
std::vector < uint32_t > addresses;
for(uint32_t i = 0; i < numBuildings; i++)
{
DFHack::t_building temp;
Bld->Read(i, temp);
if(temp.type != 0xFFFFFFFF) // check if type isn't invalid
{
std::string typestr;
mem->resolveClassIDToClassname(temp.type, typestr);
std::cout << typestr << std::endl;
if(typestr == type)
addresses.push_back(temp.origin);
}
else
{
// couldn't translate type, print out the vtable
std::cout << "unknown vtable: " << temp.vtable << std::endl;
}
}
if (addresses.empty())
{
std::cout << "No buildings matching '" << type << "'" << endl;
return;
}
interleave_hex(DF,addresses,lines / 4);
}
void doUnderCursor(DFHack::Context *DF, DFHack::VersionInfo * mem,
DFHack::Buildings * Bld, uint32_t numBuildings,
int32_t x, int32_t y, int32_t z)
{
std::map <uint32_t, std::string> custom_workshop_types;
Bld->ReadCustomWorkshopTypes(custom_workshop_types);
uint32_t num_under_cursor = 0;
for(uint32_t i = 0; i < numBuildings; i++)
{
DFHack::t_building temp;
Bld->Read(i, temp);
if( (uint32_t)x >= temp.x1
&& (uint32_t)x <= temp.x2
&& (uint32_t)y >= temp.y1
&& (uint32_t)y <= temp.y2
&& (uint32_t)z == temp.z
)
{
num_under_cursor++;
std::string typestr;
mem->resolveClassIDToClassname(temp.type, typestr);
printf("Address 0x%x, type %d (%s), %d/%d/%d\n", temp.origin,
temp.type, typestr.c_str(), temp.x1, temp.y1, temp.z);
printf("Material %d %d\n", temp.material.type,
temp.material.index);
int32_t custom;
if((custom = Bld->GetCustomWorkshopType(temp)) != -1)
{
printf("Custom workshop type %s (%d)\n",
custom_workshop_types[custom].c_str(), custom);
}
hexdump(DF, temp.origin, 34*16);
}
}
if (num_under_cursor == 0)
std::cout << "No buildings present under cursor." << endl;
}
void doListAll(DFHack::VersionInfo * mem, DFHack::Buildings * Bld,
uint32_t numBuildings)
{
std::cout << "Num buildings present: " << numBuildings << std::endl;
for(uint32_t i = 0; i < numBuildings; i++)
{
DFHack::t_building temp;
Bld->Read(i, temp);
std::string typestr;
mem->resolveClassIDToClassname(temp.type, typestr);
printf("Address 0x%x, type %d (%s), Coord %d/%d/%d\n", temp.origin,
temp.type, typestr.c_str(), temp.x1,temp.y1,temp.z);
}
}
void doFinish(DFHack::Context *DF)
{
DF->Detach();
#ifndef LINUX_BUILD
std::cout << "Done. Press any key to continue" << std::endl;
cin.ignore();
#endif
}
int main (int argc,const char* argv[])
{
int lines = 16;
bool word_per_line = false;
if (argc == 3)
{
std::string num = argv[2]; //blah. I don't care
std::istringstream ins; // Declare an input string stream.
ins.str(num); // Specify string to read.
ins >> lines; // Reads the integers from the string.
word_per_line = true;
}
DFHack::ContextManager DFMgr ("Memory.xml");
DFHack::Context *DF;
try
{
DF = DFMgr.getSingleContext();
DF->Attach();
}
catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::VersionInfo * mem = DF->getMemoryInfo();
DFHack::Buildings * Bld = DF->getBuildings();
DFHack::Gui * Gui = DF->getGui();
uint32_t numBuildings;
if(!Bld->Start(numBuildings))
{
std::cerr << "buildings not supported for this DF version" << std::endl;
doFinish(DF);
return 1;
}
if (numBuildings == 0)
{
cout << "No buildings on site." << endl;
doFinish(DF);
return 0;
}
if (word_per_line)
doWordPerLine(DF, mem, Bld, numBuildings, argv[1], lines);
else
{
int32_t x,y,z;
Gui->getCursorCoords(x,y,z);
if(x != -30000)
doUnderCursor(DF, mem, Bld, numBuildings, x, y, z);
else
doListAll(mem, Bld, numBuildings);
}
Bld->Finish();
doFinish(DF);
return 0;
}

95
tools/examples/construction_dump.cpp
Unescape Escape View File

@ -1,95 +0,0 @@
// Just show some position data
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
#include <stdio.h>
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
using namespace DFHack;
int main (int numargs, const char ** args)
{
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context* DF;
try
{
DF = DFMgr.getSingleContext();
DF->Attach();
}
catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::Gui *Gui = DF->getGui();
DFHack::Constructions *Cons = DF->getConstructions();
DFHack::Materials *Mats = DF->getMaterials();
Mats->ReadInorganicMaterials();
Mats->ReadOrganicMaterials();
uint32_t numConstr;
Cons->Start(numConstr);
int32_t cx, cy, cz;
Gui->getCursorCoords(cx,cy,cz);
if(cx != -30000)
{
t_construction con;
for(uint32_t i = 0; i < numConstr; i++)
{
Cons->Read(i,con);
if(cx == con.x && cy == con.y && cz == con.z)
{
printf("Construction %d/%d/%d @ 0x%x\n", con.x, con.y, con.z,con.origin);
// inorganic stuff - we can recognize that
printf("Material: form %d, type %d, index %d\n",con.form, con.mat_type, con.mat_idx);
std::string matstr = "unknown";
if(con.mat_type == 0)
{
if(con.mat_idx != 0xffffffff)
matstr = Mats->inorganic[con.mat_idx].id;
else matstr = "inorganic";
}
if(con.mat_type == 420)
{
if(con.mat_idx != 0xffffffff)
matstr = Mats->organic[con.mat_idx].id;
else matstr = "organic";
}
switch(con.form)
{
case constr_bar:
printf("It is made of %s bars!\n",matstr.c_str());
break;
case constr_block:
printf("It is made of %s blocks!\n",matstr.c_str());
break;
case constr_boulder:
printf("It is made of %s stones!\n",matstr.c_str());
break;
case constr_logs:
printf("It is made of %s logs!\n",matstr.c_str());
break;
default:
printf("It is made of something we don't know yet! The material is %s.\n",matstr.c_str());
}
hexdump(DF,con.origin,32);
}
}
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

528
tools/examples/creaturedump.cpp
Unescape Escape View File

@ -1,528 +0,0 @@
// Creature dump
#include <iostream>
#include <climits>
#include <string.h>
#include <vector>
#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;
vector< vector<string> > englishWords;
vector< vector<string> > foreignWords;
DFHack::Creatures * Creatures = NULL;
uint32_t current_year;
uint32_t current_tick;
/*
likeType printLike40d(DFHack::t_like like, const matGlosses & mat,const vector< vector <DFHack::t_itemType> > & itemTypes)
{ // The function in DF which prints out the likes is a monster, it is a huge switch statement with tons of options and calls a ton of other functions as well,
//so I am not going to try and put all the possibilites here, only the low hanging fruit, with stones and metals, as well as items,
//you can easily find good canidates for military duty for instance
//The ideal thing to do would be to call the df function directly with the desired likes, the df function modifies a string, so it should be possible to do...
if(like.active){
if(like.type ==0){
switch (like.material.type)
{
case 0:
cout << mat.woodMat[like.material.index].name;
return(MATERIAL);
case 1:
cout << mat.stoneMat[like.material.index].name;
return(MATERIAL);
case 2:
cout << mat.metalMat[like.material.index].name;
return(MATERIAL);
case 12: // don't ask me why this has such a large jump, maybe this is not actually the matType for plants, but they all have this set to 12
cout << mat.plantMat[like.material.index].name;
return(MATERIAL);
case 32:
cout << mat.plantMat[like.material.index].name;
return(MATERIAL);
case 121:
cout << mat.creatureMat[like.material.index].name;
return(MATERIAL);
default:
return(FAIL);
}
}
else if(like.type == 4 && like.itemIndex != -1){
switch(like.itemClass)
{
case 24:
cout << itemTypes[0][like.itemIndex].name;
return(ITEM);
case 25:
cout << itemTypes[4][like.itemIndex].name;
return(ITEM);
case 26:
cout << itemTypes[8][like.itemIndex].name;
return(ITEM);
case 27:
cout << itemTypes[9][like.itemIndex].name;
return(ITEM);
case 28:
cout << itemTypes[10][like.itemIndex].name;
return(ITEM);
case 29:
cout << itemTypes[7][like.itemIndex].name;
return(ITEM);
case 38:
cout << itemTypes[5][like.itemIndex].name;
return(ITEM);
case 63:
cout << itemTypes[11][like.itemIndex].name;
return(ITEM);
case 68:
case 69:
cout << itemTypes[6][like.itemIndex].name;
return(ITEM);
case 70:
cout << itemTypes[1][like.itemIndex].name;
return(ITEM);
default:
// cout << like.itemClass << ":" << like.itemIndex;
return(FAIL);
}
}
else if(like.material.type != -1){// && like.material.index == -1){
if(like.type == 2){
switch(like.itemClass)
{
case 52:
case 53:
case 58:
cout << mat.plantMat[like.material.type].name;
return(FOOD);
case 72:
if(like.material.type =! 10){ // 10 is for milk stuff, which I don't know how to do
cout << mat.plantMat[like.material.index].extract_name;
return(FOOD);
}
return(FAIL);
case 74:
cout << mat.plantMat[like.material.index].drink_name;
return(FOOD);
case 75:
cout << mat.plantMat[like.material.index].food_name;
return(FOOD);
case 47:
case 48:
cout << mat.creatureMat[like.material.type].name;
return(FOOD);
default:
return(FAIL);
}
}
}
}
return(FAIL);
}
*/
void printCreature(DFHack::Context * DF, const DFHack::t_creature & creature)
{
uint32_t dayoflife;
cout << "address: " << hex << creature.origin << dec << ", creature race: " << creature.race << "/" << Materials->raceEx[creature.race].rawname
<< "[" << Materials->raceEx[creature.race].tile_character
<< "," << Materials->raceEx[creature.race].tilecolor.fore
<< "," << Materials->raceEx[creature.race].tilecolor.back
<< "," << Materials->raceEx[creature.race].tilecolor.bright
<< "]"
<< ", position: " << creature.x << "x " << creature.y << "y "<< creature.z << "z" << endl;
bool addendl = false;
if(creature.name.first_name[0])
{
cout << "first name: " << creature.name.first_name;
addendl = true;
}
if(creature.name.nickname[0])
{
cout << ", nick name: " << creature.name.nickname;
addendl = true;
}
DFHack::Translation *Tran = DF->getTranslation();
DFHack::VersionInfo *mem = DF->getMemoryInfo();
string transName = Tran->TranslateName(creature.name,false);
if(!transName.empty())
{
cout << ", trans name: " << transName;
addendl=true;
}
transName = Tran->TranslateName(creature.name,true);
if(!transName.empty())
{
cout << ", last name: " << transName;
addendl=true;
}
if(creature.civ)
{
cout << ", civilization: " << creature.civ;
addendl = true;
}
/*
cout << ", likes: ";
for(uint32_t i = 0;i<creature.numLikes; i++)
{
if(printLike(creature.likes[i],mat,itemTypes))
{
cout << ", ";
}
}
*/
if(addendl)
{
cout << endl;
addendl = false;
}
cout << ", profession: " << mem->getProfession(creature.profession) << "(" << (int) creature.profession << ")";
if(creature.custom_profession[0])
{
cout << ", custom profession: " << creature.custom_profession;
}
if(creature.current_job.active)
{
try{
cout << ", current job: " << mem->getJob(creature.current_job.jobId);
}
catch(exception & e)
{
cout << e.what() << endl;
}
}
cout << endl;
dayoflife = creature.birth_year*12*28 + creature.birth_time/1200;
cout << "Born on the year " << creature.birth_year << ", month " << (creature.birth_time/1200/28) << ", day " << ((creature.birth_time/1200) % 28 + 1) << ", " << dayoflife << " days lived." << endl;
cout << "Appearance : ";
for(unsigned int i = 0; i<creature.nbcolors ; i++)
{
cout << Materials->raceEx[creature.race].castes[creature.caste].ColorModifier[i].part << " ";
uint32_t color = Materials->raceEx[creature.race].castes[creature.caste].ColorModifier[i].colorlist[creature.color[i]];
if(color<Materials->color.size())
{
cout << Materials->color[color].name << "["
<< (unsigned int) (Materials->color[color].red*255) << ":"
<< (unsigned int) (Materials->color[color].green*255) << ":"
<< (unsigned int) (Materials->color[color].blue*255) << "]";
}
else if (color < Materials->alldesc.size())
{
cout << Materials->alldesc[color].id;
}
else
{
cout << "Unknown color " << color << endl;
}
if( Materials->raceEx[creature.race].castes[creature.caste].ColorModifier[i].startdate > 0 )
{
if( (Materials->raceEx[creature.race].castes[creature.caste].ColorModifier[i].startdate <= dayoflife) &&
(Materials->raceEx[creature.race].castes[creature.caste].ColorModifier[i].enddate > dayoflife) )
cout << "[active]";
else
cout << "[inactive]";
}
cout << " - ";
}
cout << endl;
cout << "happiness: " << creature.happiness
<< ", strength: " << creature.strength.level
<< ", agility: " << creature.agility.level
<< ", toughness: " << creature.toughness.level
<< ", endurance: " << creature.endurance.level
<< ", recuperation: " << creature.recuperation.level
<< ", disease resistance: " << creature.disease_resistance.level
//<< ", money: " << creature.money
<< ", id: " << creature.id;
/*
if(creature.squad_leader_id != -1)
{
cout << ", squad_leader_id: " << creature.squad_leader_id;
}
if(creature.mood != -1){
cout << ", mood: " << creature.mood << " ";
}*/
cout << ", sex: ";
if(creature.sex == 0)
{
cout << "Female";
}
else
{
cout <<"Male";
}
cout << endl;
if((creature.mood != -1) && (creature.mood<5))
{
cout << "mood: " << creature.mood << ", skill: " << mem->getSkill(creature.mood_skill) << endl;
vector<DFHack::t_material> mymat;
if(Creatures->ReadJob(&creature, mymat))
{
for(unsigned int i = 0; i < mymat.size(); i++)
{
printf("\t%s(%d)\t%d %d %d - %.8x\n", Materials->getDescription(mymat[i]).c_str(), mymat[i].itemType, mymat[i].subType, mymat[i].subIndex, mymat[i].index, mymat[i].flags);
}
}
}
// FIXME: TOO BAD...
std::vector<uint32_t> inventory;
if( Creatures->ReadInventoryPtr(creature.origin, inventory))
{
DFHack::Items * Items = DF->getItems();
printf("\tInventory:\n");
for(unsigned int i = 0; i < inventory.size(); i++)
{
DFHack::dfh_item item;
if (Items->readItem(inventory[i], item))
printf("\t\t%d: %s\n", item.id, Items->getItemDescription(item, Materials).c_str());
}
}
std::vector<int32_t> owned;
if( Creatures->ReadOwnedItemsPtr(creature.origin, owned))
{
DFHack::Items * Items = DF->getItems();
printf("\tOwns:\n");
for (int i = 0; i < owned.size(); i++) {
uint32_t pitem = Items->findItemByID(owned[i]);
DFHack::dfh_item item;
if (!pitem || !Items->readItem(pitem,item))
pitem = 0;
printf("\t\t%d: %s\n", owned[i],
pitem ? Items->getItemDescription(item, Materials).c_str() : "?");
}
}
/*
if(creature.pregnancy_timer > 0)
cout << "gives birth in " << creature.pregnancy_timer/1200 << " days. ";
cout << "Blood: " << creature.blood_current << "/" << creature.blood_max << " bleeding: " << creature.bleed_rate;
*/
cout << endl;
if(creature.has_default_soul)
{
//skills
cout << "Skills" << endl;
for(unsigned int i = 0; i < creature.defaultSoul.numSkills;i++)
{
if(i > 0)
{
cout << ", ";
}
try
{
cout << mem->getSkill(creature.defaultSoul.skills[i].id) << ": " << creature.defaultSoul.skills[i].rating;
}
catch(DFHack::Error::AllMemdef &e)
{
cout << "Unknown skill! : " << creature.defaultSoul.skills[i].id <<", rating: " << creature.defaultSoul.skills[i].rating << endl;
cout << e.what() << endl;
}
}
cout << endl;
cout << "Traits" << endl;
for(uint32_t i = 0; i < 30;i++)
{
string trait = mem->getTrait (i, creature.defaultSoul.traits[i]);
if(!trait.empty()) cout << trait << ", ";
}
cout << endl;
// labors
cout << "Labors" << endl;
for(unsigned int i = 0; i < NUM_CREATURE_LABORS;i++)
{
if(!creature.labors[i])
continue;
string laborname;
try
{
laborname = mem->getLabor(i);
}
catch(exception &)
{
break;
}
cout << laborname << ", ";
}
cout << endl;
}
/*
* FLAGS 1
*/
cout << "flags1: ";
print_bits(creature.flags1.whole, cout);
cout << endl;
if(creature.flags1.bits.dead)
{
cout << "dead ";
}
if(creature.flags1.bits.on_ground)
{
cout << "on the ground, ";
}
if(creature.flags1.bits.skeleton)
{
cout << "skeletal ";
}
if(creature.flags1.bits.zombie)
{
cout << "zombie ";
}
if(creature.flags1.bits.tame)
{
cout << "tame ";
}
if(creature.flags1.bits.royal_guard)
{
cout << "royal_guard ";
}
if(creature.flags1.bits.fortress_guard)
{
cout << "fortress_guard ";
}
/*
* FLAGS 2
*/
cout << endl << "flags2: ";
print_bits(creature.flags2.whole, cout);
cout << endl;
if(creature.flags2.bits.killed)
{
cout << "killed by kill function, ";
}
if(creature.flags2.bits.resident)
{
cout << "resident, ";
}
if(creature.flags2.bits.gutted)
{
cout << "gutted, ";
}
if(creature.flags2.bits.slaughter)
{
cout << "marked for slaughter, ";
}
if(creature.flags2.bits.underworld)
{
cout << "from the underworld, ";
}
cout << endl;
if(creature.flags1.bits.had_mood && (creature.mood == -1 || creature.mood == 8 ) )
{
string artifact_name = Tran->TranslateName(creature.artifact_name,false);
cout << "artifact: " << artifact_name << endl;
}
cout << 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;
}
string check = "";
if(numargs == 2)
check = args[1];
Creatures = DF->getCreatures();
Materials = DF->getMaterials();
World = DF->getWorld();
current_year = World->ReadCurrentYear();
current_tick = World->ReadCurrentTick();
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;
}
if(!numCreatures)
{
cerr << "No creatures to print" << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
mem = DF->getMemoryInfo();
Materials->ReadInorganicMaterials();
Materials->ReadOrganicMaterials();
Materials->ReadWoodMaterials();
Materials->ReadPlantMaterials();
Materials->ReadCreatureTypes();
Materials->ReadCreatureTypesEx();
//Materials->ReadDescriptorColors();
if(!Tran->Start())
{
cerr << "Can't get name tables" << endl;
return 1;
}
vector<uint32_t> addrs;
for(uint32_t i = 0; i < numCreatures; i++)
{
DFHack::t_creature temp;
Creatures->ReadCreature(i,temp);
if(check.empty() || string(Materials->raceEx[temp.race].rawname) == check)
{
printCreature(DF,temp);
addrs.push_back(temp.origin);
}
}
if(addrs.size() <= 10)
{
interleave_hex(DF,addrs,200);
}
Creatures->Finish();
DF->Detach();
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

121
tools/examples/dfitemdump.cpp
Unescape Escape View File

@ -1,121 +0,0 @@
/*
* Simple, pretty item dump example.
*/
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <climits>
#include <vector>
#include <cstring>
using namespace std;
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
#include <DFVector.h>
int main (int argc, char *argv[])
{
bool print_refs = false;
bool print_hex = false;
bool print_acc = false;
for(int i = 1; i < argc; i++)
{
char *arg = argv[i];
if (arg[0] != '-')
continue;
for (; *arg; arg++) {
switch (arg[0]) {
case 'r': print_refs = true; break;
case 'x': print_hex = true; break;
case 'a': print_acc = true; break;
}
}
}
DFHack::Process * p;
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;
}
DFHack::Materials * Materials = DF->getMaterials();
Materials->ReadAllMaterials();
DFHack::Gui * Gui = DF->getGui();
DFHack::Items * Items = DF->getItems();
Items->Start();
DFHack::VersionInfo * mem = DF->getMemoryInfo();
p = DF->getProcess();
int32_t x,y,z;
Gui->getCursorCoords(x,y,z);
std::vector<uint32_t> p_items;
Items->readItemVector(p_items);
uint32_t size = p_items.size();
// FIXME: tools should never be exposed to DFHack internals!
DFHack::OffsetGroup* itemGroup = mem->getGroup("Items");
uint32_t ref_vector = itemGroup->getOffset("item_ref_vector");
for(size_t i = 0; i < size; i++)
{
DFHack::dfh_item itm;
memset(&itm, 0, sizeof(DFHack::dfh_item));
Items->readItem(p_items[i],itm);
if (x != -30000
&& !(itm.base.x == x && itm.base.y == y && itm.base.z == z
&& itm.base.flags.on_ground
&& !itm.base.flags.in_chest
&& !itm.base.flags.in_inventory
&& !itm.base.flags.in_building))
continue;
printf(
"%5d: %08x %6d %08x (%d,%d,%d) #%08x [%d] *%d %s - %s\n",
i, itm.origin, itm.id, itm.base.flags.whole,
itm.base.x, itm.base.y, itm.base.z,
itm.base.vtable,
itm.wear_level,
itm.quantity,
Items->getItemClass(itm).c_str(),
Items->getItemDescription(itm, Materials).c_str()
);
if (print_hex)
hexdump(DF,p_items[i],0x300);
if (print_acc)
cout << Items->dumpAccessors(itm) << endl;
if (print_refs) {
DFHack::DfVector<uint32_t> p_refs(p, itm.origin + ref_vector);
for (size_t j = 0; j < p_refs.size(); j++) {
uint32_t vptr = p->readDWord(p_refs[j]);
uint32_t val = p->readDWord(p_refs[j]+4);
printf("\t-> %d \t%s\n", int(val), p->readClassName(vptr).c_str());
}
}
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

105
tools/examples/engravingdump.cpp
Unescape Escape View File

@ -1,105 +0,0 @@
// Just show some position data
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
#include <stdio.h>
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
using namespace DFHack;
void describe (dfh_engraving &engraving)
{
t_engraving &data = engraving.s;
printf("Engraving %d/%d/%d @ 0x%x\n", data.x, data.y, data.z, engraving.origin);
// inorganic stuff - we can recognize that
printf("type %d, index %d, character %c\n",data.type, data.subtype_idx, data.display_character);
printf("quality %d\n",data.quality);
printf("engraved: ");
if(data.flags.floor)
printf("On the floor.");
if(data.flags.north)
printf("From north.");
if(data.flags.south)
printf("From south.");
if(data.flags.east)
printf("From east.");
if(data.flags.west)
printf("From west.");
if(data.flags.northeast)
printf("From north-east.");
if(data.flags.northwest)
printf("From north-west.");
if(data.flags.southeast)
printf("From south-east.");
if(data.flags.southwest)
printf("From south-west.");
printf("\n");
if(data.flags.hidden)
printf("The symbol is hidden.\n");
};
int main (int numargs, const char ** args)
{
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context* DF;
try
{
DF = DFMgr.getSingleContext();
DF->Attach();
}
catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::Gui *Gui = DF->getGui();
DFHack::Engravings *Cons = DF->getEngravings();
uint32_t numEngr;
Cons->Start(numEngr);
int32_t cx, cy, cz;
Gui->getCursorCoords(cx,cy,cz);
if(cx != -30000)
{
dfh_engraving engraved;
t_engraving &data = engraved.s;
for(uint32_t i = 0; i < numEngr; i++)
{
Cons->Read(i,engraved);
if(cx == data.x && cy == data.y && cz == data.z)
{
describe(engraved);
hexdump(DF,engraved.origin,0x28);
}
}
}
else
{
dfh_engraving engraved;
t_engraving &data = engraved.s;
for(uint32_t i = 0; i < numEngr; i++)
{
Cons->Read(i,engraved);
{
describe(engraved);
hexdump(DF,engraved.origin,0x28);
}
}
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

66
tools/examples/hotkeynotedump.cpp
Unescape Escape View File

@ -1,66 +0,0 @@
// Hotkey and Note Dump
// Or Hot Keynote Dump? :P
#include <iostream>
#include <climits>
#include <vector>
using namespace std;
#include <DFHack.h>
int main (void)
{
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;
}
DFHack::VersionInfo * mem = DF->getMemoryInfo();
DFHack::Gui * Gui = DF->getGui();
// get stone matgloss mapping
/*
uint32_t numNotes;
if(!DF.InitReadNotes(numNotes))
{
cerr << "Can't get notes" << endl;
return 1;
}
*/
/*
cout << "Notes" << endl;
for(uint32_t i = 0; i < numNotes; i++)
{
DFHack::t_note temp;
DF.ReadNote(i,temp);
cout << "x: " << temp.x << "\ty: " << temp.y << "\tz: " << temp.z <<
"\tsymbol: " << temp.symbol << "\tfg: " << temp.foreground << "\tbg: " << temp.background <<
"\ttext: " << temp.name << endl;
}
*/
cout << "Hotkeys" << endl;
DFHack::t_hotkey hotkeys[NUM_HOTKEYS];
Gui->ReadHotkeys(hotkeys);
for(uint32_t i =0;i< NUM_HOTKEYS;i++)
{
cout << "x: " << hotkeys[i].x << "\ty: " << hotkeys[i].y << "\tz: " << hotkeys[i].z <<
"\ttext: " << hotkeys[i].name << endl;
}
//DF.FinishReadNotes();
DF->Detach();
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

149
tools/examples/materialtest.cpp
Unescape Escape View File

@ -1,149 +0,0 @@
// Just show some position data
#include <iostream>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
using namespace std;
#include <DFHack.h>
int main (int numargs, const char ** args)
{
uint32_t addr;
if (numargs == 2)
{
istringstream input (args[1],istringstream::in);
input >> std::hex >> addr;
}
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;
}
DFHack::Process* p = DF->getProcess();
DFHack::VersionInfo* mem = DF->getMemoryInfo();
DFHack::Materials *Materials = DF->getMaterials();
cout << "----==== Inorganic ====----" << endl;
Materials->ReadInorganicMaterials ();
for(uint32_t i = 0; i < Materials->inorganic.size();i++)
{
cout << i << ": " << Materials->inorganic[i].id << endl;
}
cout << endl << "----==== Organic ====----" << endl;
Materials->ReadOrganicMaterials ();
for(uint32_t i = 0; i < Materials->organic.size();i++)
{
cout << i << ": " << Materials->organic[i].id << endl;
}
cout << endl << "----==== Organic - trees ====----" << endl;
Materials->ReadWoodMaterials ();
for(uint32_t i = 0; i < Materials->tree.size();i++)
{
cout << i << ": " << Materials->tree[i].id << endl;
}
cout << endl << "----==== Organic - plants ====----" << endl;
Materials->ReadPlantMaterials ();
for(uint32_t i = 0; i < Materials->plant.size();i++)
{
cout << i << ": " << Materials->plant[i].id << endl;
}
cout << endl << "----==== Color descriptors ====----" << endl;
Materials->ReadDescriptorColors();
for(uint32_t i = 0; i < Materials->color.size();i++)
{
cout << i << ": " << Materials->color[i].id << " - " << Materials->color[i].name << "["
<< (unsigned int) (Materials->color[i].red*255) << ":"
<< (unsigned int) (Materials->color[i].green*255) << ":"
<< (unsigned int) (Materials->color[i].blue*255)
<< "]" << endl;
}
cout << endl << "----==== All descriptors ====----" << endl;
Materials->ReadDescriptorColors();
for(uint32_t i = 0; i < Materials->alldesc.size();i++)
{
cout << i << ": " << Materials->alldesc[i].id << endl;
}
cout << endl << "----==== Creature types ====----" << endl;
Materials->ReadCreatureTypesEx ();
for(uint32_t i = 0; i < Materials->raceEx.size();i++)
{
cout << i << ": " << Materials->raceEx[i].rawname << endl;
vector<DFHack::t_creaturecaste> & castes = Materials->raceEx[i].castes;
for(uint32_t j = 0; j < castes.size();j++)
{
cout << " ["
<< castes[j].rawname << ":"
<< castes[j].singular << ":"
<< castes[j].plural << ":"
<< castes[j].adjective << "] ["
<< "st:" << castes[j].strength.level << "/"
<< "ag:" << castes[j].agility.level << "/"
<< "to:" << castes[j].toughness.level << "/"
<< "en:" << castes[j].endurance.level << "/"
<< "re:" << castes[j].recuperation.level << "/"
<< "di:" << castes[j].disease_resistance.level << "/"
<< "an:" << castes[j].analytical_ability.level << "/"
<< "fo:" << castes[j].focus.level << "/"
<< "wi:" << castes[j].willpower.level << "/"
<< "cr:" << castes[j].creativity.level << "/"
<< "in:" << castes[j].intuition.level << "/"
<< "pa:" << castes[j].patience.level << "/"
<< "me:" << castes[j].memory.level << "/"
<< "li:" << castes[j].linguistic_ability.level << "/"
<< "sp:" << castes[j].spatial_sense.level << "/"
<< "mu:" << castes[j].musicality.level << "/"
<< "ki:" << castes[j].kinesthetic_sense.level << "]";
cout << endl;
for(uint32_t k = 0; k < castes[j].ColorModifier.size(); k++)
{
cout << " colormod[" << castes[j].ColorModifier[k].part;
if(castes[j].ColorModifier[k].startdate>0)
cout << " start:" << castes[j].ColorModifier[k].startdate << " days, end:" << castes[j].ColorModifier[k].enddate << " days";
cout << "] ";
for(uint32_t l = 0; l < castes[j].ColorModifier[k].colorlist.size(); l++)
{
if( castes[j].ColorModifier[k].colorlist[l] < Materials->color.size() )
cout << Materials->color[castes[j].ColorModifier[k].colorlist[l]].name << " ";
else
cout << Materials->alldesc[castes[j].ColorModifier[k].colorlist[l]].id << " ";
}
cout << endl;
}
cout << " body: ";
for(uint32_t k = 0; k < castes[j].bodypart.size(); k++)
{
cout << castes[j].bodypart[k].category << " ";
}
cout << endl;
}
cout << endl;
}
cout << endl << "----==== Other ====----" << endl;
Materials->ReadOthers ();
for(uint32_t i = 0; i < Materials->other.size();i++)
{
cout << i << ": " << Materials->other[i].rawname << endl;
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

146
tools/examples/processenum.cpp
Unescape Escape View File

@ -1,146 +0,0 @@
// Demonstrates the use of ProcessEnumerator
// queries the Enumerator for all DF Processes on user input. Prints them to the terminal.
// also tracks processes that were invalidated
#include <iostream>
#include <climits>
#include <vector>
#include <ctime>
using namespace std;
#include <DFHack.h>
#include <DFProcessEnumerator.h>
using namespace DFHack;
#ifndef LINUX_BUILD
#endif
void printhelp ()
{
cout << "enter empty line for next try." << endl;
cout << "enter 'next' or 'n' for next test." << endl;
cout << "enter 'help' to show this text again." << endl;
}
int inputwait (const char * prompt)
{
inputwait_reset:
string command = "";
cout <<"[" << prompt << "]# ";
getline(cin, command);
if(command == "help")
{
printhelp();
goto inputwait_reset;
}
else if(command == "")
{
return 1;
}
else if(command == "next")
{
return 0;
}
else
{
cout << "Command not recognized. Try 'help' for a list of valid commands." << endl;
goto inputwait_reset;
}
return 0;
}
int main (void)
{
printhelp();
cout << endl;
// first test ProcessEnumerator and BadProcesses
{
cout << "Testing ProcessEnumerator" << endl;
ProcessEnumerator Penum("Memory.xml");
VersionInfo * mem;
do
{
// make the ProcessEnumerator update its list of Processes
// by passing the pointer to 'inval', we make it export expired
// processes instead of destroying them outright
// (processes expire when the OS kills them for whatever reason)
BadProcesses inval;
Penum.Refresh(&inval);
int nProc = Penum.size();
int nInval = inval.size();
cout << "Processes:" << endl;
for(int i = 0; i < nProc; i++)
{
mem = Penum[i]->getDescriptor();
cout << "DF instance: " << Penum[i]->getPID()
<< ", " << mem->getVersion() << endl;
}
cout << "Invalidated:" << endl;
for(int i = 0; i < nInval; i++)
{
mem = inval[i]->getDescriptor();
cout << "DF instance: " << inval[i]->getPID()
<< ", " << mem->getVersion() << endl;
}
}
while(inputwait("ProcessEnumerator"));
}
// next test ContextManager and BadContexts
{
cout << "Testing ContextManager" << endl;
ContextManager Cman("Memory.xml");
VersionInfo * mem;
do
{
// make the ContextManager update its list of Contexts
// by passing the pointer to 'inval', we make it export expired
// contexts instead of destroying them outright
// (contexts expire when the OS kills their process for whatever
// reason)
BadContexts inval;
Cman.Refresh(&inval);
int nCont = Cman.size();
int nInval = inval.size();
DFHack::Context * cont = Cman.getSingleContext();
if(cont)
{
if(cont->Attach())
{
DFHack::Maps * mapz = cont->getMaps();
cont->Suspend();
mapz->Start();
cont->Resume();
}
bool result = cont->Detach();
if(!result)
{
cerr << "Something went horribly wrong during detach" << endl;
}
}
cout << "Contexts:" << endl;
for(int i = 0; i < nCont; i++)
{
mem = Cman[i]->getMemoryInfo();
cout << "DF instance: " << Cman[i]->getProcess()->getPID()
<< ", " << mem->getVersion() << endl;
}
cout << "Invalidated:" << endl;
for(int i = 0; i < nInval; i++)
{
mem = inval[i]->getMemoryInfo();
cout << "DF instance: " << inval[i]->getProcess()->getPID()
<< ", " << mem->getVersion() << endl;
}
}
while(inputwait("ContextManager"));
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

85
tools/examples/settlementdump.cpp
Unescape Escape View File

@ -1,85 +0,0 @@
#include <iostream>
#include <iomanip>
#include <sstream>
#include <climits>
#include <integers.h>
#include <vector>
using namespace std;
#include <DFTypes.h>
#include <DFHackAPI.h>
#include <stdio.h>
void printSettlement(DFHack::ContextManager & DF, const DFHack::t_settlement & settlement, const vector< vector<string> > &englishWords, const vector< vector<string> > &foreignWords)
{
cout << "First name: " << settlement.name.first_name << endl << "Nickname: " << settlement.name.nickname << endl;
cout << settlement.name.words[0] << " " << settlement.name.words[1] << " " << settlement.name.words[2] << " "
<< settlement.name.words[3] << " " << settlement.name.words[4] << " " << settlement.name.words[5] << " "
<< settlement.name.words[6] << " " << settlement.name.words[7] << endl;
cout << settlement.name.parts_of_speech[0] << " " << settlement.name.parts_of_speech[1] << " " << settlement.name.parts_of_speech[2] << " "
<< settlement.name.parts_of_speech[3] << " " << settlement.name.parts_of_speech[4] << " " << settlement.name.parts_of_speech[5] << " "
<< settlement.name.parts_of_speech[6] << " " << settlement.name.parts_of_speech[7] << endl;
printf("Origin: 0x%x\n",settlement.origin);
string genericName = DF.TranslateName(settlement.name,englishWords,foreignWords,true);
string dwarfName = DF.TranslateName(settlement.name,englishWords,foreignWords,false);
cout << dwarfName << " " << genericName << " " << "world x: " << settlement.world_x << " world y: " << settlement.world_y
<< " local_x: " << settlement.local_x1 << " local_y: " << settlement.local_y1 << " size: " << settlement.local_x2 - settlement.local_x1 << " by " << settlement.local_y2 - settlement.local_y1 << "\n";
}
int main (int argc,const char* argv[])
{
DFHack::ContextManager DF("Memory.xml");
try
{
DF.Attach();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::t_settlement current;
uint32_t numSettlements;
if(!DF.InitReadSettlements(numSettlements))
{
cerr << "Could not read Settlements" << endl;
return 1;
}
vector< vector<string> > englishWords;
vector< vector<string> > foreignWords;
if(!DF.InitReadNameTables(englishWords,foreignWords))
{
cerr << "Can't get name tables" << endl;
return 1;
}
cout << "Settlements\n";
/*for(uint32_t i =0;i<numSettlements;i++){
DFHack::t_settlement temp;
DF.ReadSettlement(i,temp);
printSettlement(DF,temp,englishWords,foreignWords);
}*/
// MSVC claims this is causing the heap to be corrupted, I think it is because the currentSettlement vector only has 1 item in it
cout << "Current Settlement\n";
if(DF.ReadCurrentSettlement(current))
printSettlement(DF,current,englishWords,foreignWords);
DF.FinishReadNameTables();
DF.FinishReadSettlements();
DF.Detach();
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

197
tools/examples/spatterdump.cpp
Unescape Escape View File

@ -1,197 +0,0 @@
// Just show some position data
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
using namespace std;
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
using namespace DFHack;
//FIXME: A pile of magic numbers. looks like decompiled number
typedef uint32_t _DWORD;
int get_material_vector(uint32_t vein_8, uint16_t vein_4, int WORLD_)
{
int result; // eax@2
int v4; // ecx@11
int v5; // eax@12
if ( (uint16_t)(vein_4 - 0x1A3) > 0xC7u )
{
if ( ((int16_t)vein_4 < 19 || (int16_t)vein_4 > 0xDAu)
&& (uint16_t)(vein_4 - 219) > 0xC7u )
{
if ( vein_4 )
{
if ( vein_4 > 0x292u )
result = 0;
else
result = *(_DWORD *)(WORLD_ + 4 * (int16_t)vein_4 + 0x5DF44);
}
else
{
if ( (signed int)vein_8 >= 0
&& (v4 = *(_DWORD *)(WORLD_ + 0x54B88), vein_8 < (*(_DWORD *)(WORLD_ + 0x54B8C) - v4) >> 2)
&& (v5 = *(_DWORD *)(v4 + 4 * vein_8)) != 0 )
result = v5 + 0x178;
else
result = *(_DWORD *)(WORLD_ + 0x5DF44);
}
}
else
{
/*
result = sub_4D47A0(vein_8, vein_4, WORLD_ + 0x54C84);
if ( !result )
result = *(_DWORD *)(WORLD_ + 0x5DF90);
*/
}
}
else
{
/*
result = sub_41F430(WORLD_ + 0x54B94, vein_4);
if ( !result )
result = *(_DWORD *)(WORLD_ + 0x5E5D0);
*/
}
return result;
}
char shades[10] = {'#','$','O','=','+','|','-','^','.',' '};
void printSpatter(DFHack::Context * DF, t_spattervein & spatter)
{
DFHack::Materials *Mats = DF->getMaterials();
printf("Splatter\nmat1: %d\nunknown: %d\nmat2: %d\n",spatter.mat1,spatter.unk1,spatter.mat2);
printf ("Material : %d - ", spatter.matter_state);
// FIXME: stupid
switch(spatter.matter_state)
{
case state_gas:
printf("Gas ");
break;
case state_solid:
printf("Solid ");
break;
case state_liquid:
printf("Liquid ");
break;
case state_paste:
printf("Paste ");
break;
case state_powder:
printf("Powder ");
break;
case state_pressed:
printf("Pressed ");
break;
default:
printf("Unknown state ");
}
cout << PrintSplatterType(spatter.mat1,spatter.mat2,Mats->race) << endl;
printf("Address 0x%08x\n",spatter.address_of);
for(uint32_t yyy = 0; yyy < 16; yyy++)
{
cout << "|";
for(uint32_t xxx = 0; xxx < 16; xxx++)
{
uint8_t intensity = spatter.intensity[xxx][yyy];
cout << shades[9 - (intensity / 28)];
}
cout << "|" << endl;
}
hexdump(DF, spatter.address_of,20*16);
}
int main (int numargs, const char ** args)
{
uint32_t x_max,y_max,z_max;
vector<t_vein> veinVector;
vector<t_frozenliquidvein> IceVeinVector;
vector<t_spattervein> splatter;
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;
}
DFHack::Maps *Maps =DF->getMaps();
DFHack::Gui *Gui =DF->getGui();
DFHack::Materials *Mats =DF->getMaterials();
Mats->ReadCreatureTypes();
// init the map
if(!Maps->Start())
{
cerr << "Can't init map." << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
int32_t cx, cy, cz;
Maps->getSize(x_max,y_max,z_max);
Gui->getCursorCoords(cx,cy,cz);
if(cx == -30000)
{
// walk the map
for(uint32_t x = 0; x< x_max;x++) for(uint32_t y = 0; y< y_max;y++) for(uint32_t z = 0; z< z_max;z++)
{
if(Maps->isValidBlock(x,y,z))
{
// look for splater veins
Maps->ReadVeins(x,y,z,0,0,&splatter);
if(splatter.size())
{
printf("Block %d/%d/%d\n",x,y,z);
for(uint32_t i = 0; i < splatter.size(); i++)
{
cout << i << ":" << endl;
printSpatter(DF,splatter[i]);
}
}
}
}
}
else
{
uint32_t bx,by,bz;
bx = cx / 16;
by = cy / 16;
bz = cz;
// look for splater veins
Maps->ReadVeins(bx,by,bz,0,0,&splatter);
if(splatter.size())
{
printf("Block %d/%d/%d\n",bx,by,bz);
for(uint32_t i = 0; i < splatter.size(); i++)
{
printSpatter(DF,splatter[i]);
cout << endl;
}
}
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

146
tools/examples/treedump.cpp
Unescape Escape View File

@ -1,146 +0,0 @@
// Just show some position data
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
using namespace std;
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
/*
uint16_t material; // +0x3E
uint16_t x; // +0x40
uint16_t y; // +0x42
uint16_t z; // +0x44
uint16_t padding; // +0x46
uint32_t unknown_1; // +0x48
uint16_t temperature_1; // +0x4C
uint16_t temperature_2; // +0x4E - maybe fraction?
uint32_t mystery_flag; // 0x50: yes, just one
uint32_t unknown_2; // 0x54
uint32_t unknown_3; // 0x58
// a vector is here
uint32_t address;
*/
void print_tree( DFHack::Context * DF , DFHack::dfh_plant & tree)
{
DFHack::Materials * mat = DF->getMaterials();
DFHack::t_plant & tdata = tree.sdata;
printf("%d:%d = ",tdata.type,tdata.material);
if(tdata.watery)
{
cout << "near-water ";
}
cout << mat->organic[tdata.material].id << " ";
if(!tdata.is_shrub)
{
cout << "tree";
}
else
{
cout << "shrub";
}
cout << endl;
printf("Grow counter: 0x%08x\n", tdata.grow_counter);
printf("temperature 1: %d\n", tdata.temperature_1);
printf("temperature 2: %d\n", tdata.temperature_2);
printf("On fire: %d\n", tdata.is_burning);
printf("hitpoints: 0x%08x\n", tdata.hitpoints);
printf("update order: %d\n", tdata.update_order);
printf("Address: 0x%x\n", tree.address);
hexdump(DF,tree.address,13*16);
}
int main (int numargs, const char ** args)
{
uint32_t addr;
if (numargs == 2)
{
istringstream input (args[1],istringstream::in);
input >> std::hex >> addr;
}
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;
}
DFHack::Process* p = DF->getProcess();
DFHack::VersionInfo* mem = DF->getMemoryInfo();
DFHack::Gui * Gui = DF->getGui();
DFHack::Vegetation * v = DF->getVegetation();
DFHack::Maps * mps = DF->getMaps();
DFHack::Materials * mat = DF->getMaterials();
mat->ReadOrganicMaterials();
int32_t x,y,z;
Gui->getCursorCoords(x,y,z);
uint32_t numVegs = 0;
v->Start(numVegs);
if(x == -30000)
{
cout << "----==== Trees ====----" << endl;
for(uint32_t i =0; i < numVegs; i++)
{
DFHack::dfh_plant tree;
v->Read(i,tree);
printf("%d/%d/%d, %d:%d\n",tree.sdata.x,tree.sdata.y,tree.sdata.z,tree.sdata.type,tree.sdata.material);
}
}
else
{
// new method, gets the vector of trees in a block. can show farm plants
if(mps->Start())
{
vector<DFHack::dfh_plant> alltrees;
if(mps->ReadVegetation(x/16,y/16,z,&alltrees))
{
for(int i = 0 ; i < alltrees.size(); i++)
{
DFHack::dfh_plant & tree = alltrees[i];
// you could take the tree coords from the struct and % them with 16 for use in loops over the whole block
if(tree.sdata.x == x && tree.sdata.y == y && tree.sdata.z == z)
{
cout << "----==== Tree at "<< x << "/" << y << "/" << z << " ====----" << endl;
print_tree(DF, tree);
break;
}
}
}
}
// old method, gets the tree from the global vegetation vector. can't show farm plants
for(uint32_t i =0; i < numVegs; i++)
{
DFHack::dfh_plant tree;
v->Read(i,tree);
if(tree.sdata.x == x && tree.sdata.y == y && tree.sdata.z == z)
{
cout << "----==== Tree at "<< dec << x << "/" << y << "/" << z << " ====----" << endl;
print_tree(DF, tree);
break;
}
}
}
v->Finish();
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

66
tools/playground/blockflags.cpp
Unescape Escape View File

@ -1,66 +0,0 @@
// Invert/toggle all block flags, to see what they do.
// Seems like they don't do anything...
#include <iostream>
#include <iomanip>
using namespace std;
#include <DFHack.h>
#include <extra/MapExtras.h>
#include <extra/termutil.h>
int main(int argc, char *argv[])
{
bool temporary_terminal = TemporaryTerminal();
uint32_t x_max = 0, y_max = 0, z_max = 0;
DFHack::ContextManager manager("Memory.xml");
DFHack::Context *context = manager.getSingleContext();
if (!context->Attach())
{
std::cerr << "Unable to attach to DF!" << std::endl;
if(temporary_terminal)
std::cin.ignore();
return 1;
}
DFHack::Maps *maps = context->getMaps();
if (!maps->Start())
{
std::cerr << "Cannot get map info!" << std::endl;
context->Detach();
if(temporary_terminal)
std::cin.ignore();
return 1;
}
maps->getSize(x_max, y_max, z_max);
MapExtras::MapCache map(maps);
for(uint32_t z = 0; z < z_max; z++)
{
for(uint32_t b_y = 0; b_y < y_max; b_y++)
{
for(uint32_t b_x = 0; b_x < x_max; b_x++)
{
// Get the map block
DFHack::DFCoord blockCoord(b_x, b_y);
MapExtras::Block *b = map.BlockAt(DFHack::DFCoord(b_x, b_y, z));
if (!b || !b->valid)
{
continue;
}
DFHack::t_blockflags flags = b->BlockFlags();
flags.whole = flags.whole ^ 0xFFFFFFFF;
b->setBlockFlags(flags);
b->Write();
} // block x
} // block y
} // z
maps->Finish();
context->Detach();
return 0;
}

133
tools/playground/dftry.cpp
Unescape Escape View File

@ -1,133 +0,0 @@
#include <iostream>
#include <fstream>
#include <sstream>
#include <DFHack.h>
using namespace std;
bool getNumber (string prompt, int & output, int def, bool pdef = true)
{
cout << prompt;
if(pdef)
cout << ", default=" << def << endl;
while (1)
{
string select;
cout << ">>";
std::getline(cin, select);
if(select.empty())
{
output = def;
break;
}
else if( sscanf(select.c_str(), "%d", &output) == 1 )
{
break;
}
else
{
continue;
}
}
return true;
}
bool splitvector(const vector<uint64_t> & in, vector<uint64_t> & out1, vector<uint64_t> & out2)
{
size_t length = in.size();
if(length > 1)
{
size_t split = length / 2;
out1.clear();
out2.clear();
out1.insert(out1.begin(),in.begin(),in.begin() + split);
out2.insert(out2.begin(),in.begin() + split,in.end());
return true;
}
return false;
}
void printvector (const vector<uint64_t> &in)
{
cout << "[" << endl;
for(size_t i = 0; i < in.size(); i++)
{
cout << hex << in[i] << endl;
}
cout << "]" << endl;
}
bool tryvals (DFHack::Context * DF, const vector<uint64_t> &in, uint8_t current, uint8_t testing)
{
DF->Suspend();
DFHack::Process * p = DF->getProcess();
for(size_t i = 0; i < in.size(); i++)
{
p->writeByte(in[i],testing);
}
DF->Resume();
int result;
while (!getNumber("Is the change good? 0 for no, positive for yes.",result,0));
DF->Suspend();
for(size_t i = 0; i < in.size(); i++)
{
p->writeByte(in[i],current);
}
DF->Resume();
if(result)
return true;
return false;
}
bool dotry (DFHack::Context * DF, const vector<uint64_t> &in, uint8_t current, uint8_t testing)
{
vector <uint64_t> a, b;
bool found = false;
if(!tryvals(DF,in,current,testing))
return false;
if(splitvector(in, a,b))
{
if(dotry(DF, a, current, testing))
return true;
if(dotry(DF, b, current, testing))
return true;
return false;
}
return false;
}
int main()
{
vector <uint64_t> addresses;
vector <uint64_t> a1;
vector <uint64_t> a2;
vector <uint8_t> values;
string line;
DFHack::ContextManager CM("Memory.xml");
DFHack::Context * DF = CM.getSingleContext();
if(!DF)
return 1;
DF->Resume();
ifstream fin("siege.txt");
if(!fin.is_open())
return 1;
do
{
getline(fin,line);
stringstream input (line);
input << hex;
uint64_t value;
input >> value;
if(value)
{
cout << hex << value << endl;
addresses.push_back(value);
}
} while (!fin.eof());
int val_current,val_testing;
while (!getNumber("Insert current value",val_current,1));
while (!getNumber("Insert testing value",val_testing,0));
dotry(DF, addresses,val_current,val_testing);
return 0;
}

111
tools/playground/findnameindexes.cpp
Unescape Escape View File

@ -1,111 +0,0 @@
// Dwarf fortress names are a complicated beast, in objects they are displayed
// as indexes into the language vectors
//
// use this tool if you are trying to find what the indexes are for a displayed
// name, so you can then search for it in your object
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;
#include <DFHack.h>
// returns a lower case version of the string
string tolower (const string & s)
{
string d (s);
transform (d.begin (), d.end (), d.begin (), (int(*)(int)) tolower);
return d;
}
string groupBy2(const string & s)
{
string d;
for(int i =2;i<s.length();i++){
if(i%2==0)
{
d+= s.substr(i-2,2) + " ";
}
}
d+=s.substr(s.length()-2,2);
return(d);
}
uint32_t endian_swap(uint32_t x)
{
x = (x>>24) |
((x<<8) & 0x00FF0000) |
((x>>8) & 0x0000FF00) |
(x<<24);
return x;
}
int main (void)
{
DFHack::ContextManager DF("Memory.xml");
DFHack::Context * C;
DFHack::Translation * Tran;
try
{
C = DF.getSingleContext();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
Tran = C->getTranslation();
if(!Tran->Start())
{
cerr << "Could not get Names" << endl;
return 1;
}
DFHack::Dicts dicts = *(Tran->getDicts());
DFHack::DFDict & englishWords = dicts.translations;
DFHack::DFDict & foreignWords = dicts.foreign_languages;
C->Detach();
string input;
cout << "\nSelect Name to search or q to Quit" << endl;
getline (cin, input);
while(input != "q"){
for( uint32_t i = 0; i < englishWords.size();i++){
for( uint32_t j = 0;j < englishWords[i].size();j++){
if(englishWords[i][j] != ""){
uint32_t found = tolower(input).find(tolower(englishWords[i][j]));
if(found != string::npos){
stringstream value;
value << setfill('0') << setw(8) << hex << endian_swap(j);
cout << englishWords[i][j] << " " << groupBy2(value.str()) << endl;
}
}
}
}
for( uint32_t i = 0; i < foreignWords.size();i++){
for( uint32_t j = 0;j < foreignWords[i].size();j++){
uint32_t found = tolower(input).find(tolower(foreignWords[i][j]));
if(found != string::npos){
stringstream value;
value << setfill('0') << setw(8) << hex << endian_swap(j);
cout << foreignWords[i][j] << " " << groupBy2(value.str()) << endl;
}
}
}
getline(cin,input);
}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

1355
tools/playground/hexsearch2.c
View File

File diff suppressed because it is too large Load Diff

219
tools/playground/hexsearch2.h
Unescape Escape View File

@ -1,219 +0,0 @@
/*
* Author: Silas Dunsmore aka 0x517A5D vim:ts=4:sw=4
*
* Released under the MIT X11 license; feel free to use some or all of this
* code, as long as you include the copyright and license statement (below)
* in all copies of the source code. In fact, I truly encourage reuse.
*
* If you do use large portions of this code, I suggest but do not require
* that you keep this code in a seperate file (such as this hexsearch.h file)
* so that it is clear that the terms of the license do not also apply to
* your code.
*
* Should you make fundamental changes, or bugfixes, to this code, I would
* appreciate it if you would give me a copy of your changes.
*
*
* Copyright (C) 2007-2008 Silas Dunsmore
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* See also: http://www.opensource.org/licenses/mit-license.php
* and http://en.wikipedia.org/wiki/MIT_License
*/
#ifndef HEXSEARCH_H
#define HEXSEARCH_H
#ifdef __cplusplus
extern "C"
{
#endif
extern DWORD df_memory_base, df_memory_start, df_memory_end;
extern HANDLE df_h_process, df_h_thread;
extern DWORD df_pid, df_main_win_tid;
extern DWORD here[16];
extern DWORD target[16];
// ============================================================================
// export these in case you need to work with them directly.
//extern HANDLE df_h_process, df_h_thread;
//extern DWORD df_pid, df_main_win_tid;
extern char *errormessage;
// ============================================================================
// send info to KERNEL32:OutputDebugString(), useful for non-console programs.
// (you can watch this with SysInternals' DebugView.)
// http://www.microsoft.com/technet/sysinternals/Miscellaneous/DebugView.mspx
void d_printf(const char *format, ...);
// it turned out that dprintf() is semi-standard to printf to a file descriptor.
// ============================================================================
// encapsulate the housekeeping.
BOOL open_dwarf_fortress(void);
void close_dwarf_fortress(void); // is not (normally) necessary because
// it is done at exit time.
// ============================================================================
// memory reads and writes (peeks and pokes, in old BASIC terminology)
BOOL isvalidaddress(DWORD ea);
BOOL peekarb(DWORD ea, OUT void *data, DWORD len);
BYTE peekb(DWORD ea);
WORD peekw(DWORD ea);
DWORD peekd(DWORD ea);
char *peekstr(DWORD ea, OUT char *data, DWORD maxlen);
char *peekustr(DWORD ea, OUT char *data, DWORD maxlen);
BOOL pokearb(DWORD ea, const void *data, DWORD len);
BOOL pokeb(DWORD ea, BYTE data);
BOOL pokew(DWORD ea, WORD data);
BOOL poked(DWORD ea, DWORD data);
BOOL pokestr(DWORD ea, const BYTE *data);
// ============================================================================
// The name has changed because the API HAS CHANGED!
//
// Now instead of returning HERE, it always returns the start of the match.
//
// However, there is an array, here[], that is filled with the locations of
// the HERE tokens.
// (Starting at 1. here[0] is a copy of the start of the match.)
//
// The here[] array, starting at 1, is filled with the locations of the
// HERE token.
// here[0] is a copy of the start of the match.
//
// Also, the target[] array, starting at 1, is filled with the target
// addresses of all CALL, JMP, JZ, JNZ, and JCC tokens.
//
// Finally, you no longer pass it a search length. Instead, each set of
// search terms must end with an EOL.
//
//
//
// Okay, I admit this one is complicated. Treat it as a black box.
//
// Search Dwarf Fortress's code and initialized data segments for a pattern.
// (Does not search stack, heap, or thread-local memory.)
//
// Parameters: any number of search tokens, all unsigned ints.
// The last token must be EOL.
//
// 0x00 - 0xFF: Match this byte.
// EOL: End-of-list. The match succeeds when this token is reached.
// ANYBYTE: Match any byte.
// DWORD_: Followed by a dword. Exact-match the dword.
// Equivalent to 4 match-this-byte tokens.
// ANYDWORD: Match any dword. Equivalant to 4 ANYBYTEs.
// HERE: Put the current address into the here[] array.
// SKIP_UP_TO, nn: Allow up to nn bytes between the previous match
// and the next match. The next token must be a match-this-byte
// token. There is sweet, sweet backtracking.
// EITHER: Accept either of the next two tokens as a match.
// Both must be match-this-byte tokens.
// RANGE_LO, nn: Set low byte for a range comparison. DEPRECATED.
// RANGE_HI, nn: Set high byte for a range comparison, and do the
// comparison. Should immediately follow a RANGE_LO. DEPRECATED.
// BYTERANGE, nn, mm: followed by two bytes, the low and high limits
// of the range. This is the new way to do ranges.
// DWORDRANGE, nnnnnnnn, mmmmmmmm: works like BYTERANGE.
// ADDRESS: Accept any legal address in the program's text.
// DOES NOT accept pointers into heap space and such.
// CALL: Match a near call instruction to a reasonable address.
// JUMP: Match a short or near unconditional jump to a reasonable
// address.
// JZ: Match a short or long jz (jump if zero) instruction.
// JNZ: Match a short or long jnz (jump if not zero) instruction.
// JCC: Match any short or long conditional jump instruction.
// More tokens can easily be added.
//
// Returns the offset in Dwarf Fortress of the first match of the pattern.
// Also sets global variables here[] and target[].
//
// Note: starting a pattern with ANYBYTE, ANYDWORD, SKIP_UP_TO, or EOL
// is explicitly illegal.
//
#define EOL 0x100
#define ANYBYTE 0x101
//#define FF_OR_00 0x102 // deprecated
#define HERE 0x103
#define EITHER 0x104
#define SKIP_UP_TO 0x105
#define RANGE_LO 0x106 // deprecated
#define RANGE_HI 0x107 // deprecated
#define DWORD_ 0x108
#define ANYDWORD 0x109
#define ADDRESS 0x10A
#define BYTERANGE 0x10B
#define DWORDRANGE 0x10C
#define JZ 0x174
#define JNZ 0x175
#define JCC 0x170
#define CALL 0x1E8
#define JUMP 0x1E9
DWORD hexsearch2(DWORD token1, ...);
// You can use this to limit the search to a particular part of memory.
// Use 0 for start to search from the very start of Dwarf Fortress.
// Use 0 for end to stop searching at the very end of Dwarf Fortress.
void set_hexsearch2_limits(DWORD start, DWORD end);
// ============================================================================
// patch2() and verify2() support a modified subset of hex_search2() tokens:
// The names changed because the API HAS CHANGED!
//
// 0x00 - 0xFF: pokes the byte.
// EOL: End-of-list. Allows you to specify count as 10000 or so
// and terminate (with success) when this token is reached.
// DWORD_: Followed by a DWORD. Pokes the DWORD.
// CALL: given an _address_; pokes near call with the proper _delta_.
// JUMP: given an _address_; pokes near jump with the proper _delta_.
// JZ: given an _address_; assembles a near (not short) jz & delta.
// JNZ: given an _address_; assembles a near jnz & delta.
//
// Particularly note that, unlike hex_search(), CALL, JUMP, JZ, and JNZ
// are followed by a dword-sized target address.
//
// Note that patch2() does its own verify(), so you don't have to.
// TODO: is verify() useful enough to maintain?
// Make an offset in Dwarf Fortress have certain bytes.
BOOL patch2(DWORD offset, ...);
// Check that an offset in Dwarf Fortress has certain bytes.
BOOL verify2(DWORD offset, ...);
#ifdef __cplusplus
}
#endif
#endif // HEXSEARCH_H

5
tools/playground/lumberjack.cpp
Unescape Escape View File

@ -1,5 +0,0 @@
int main (int numargs, const char ** args)
{
return 0;
}

119
tools/playground/moodump.cpp
Unescape Escape View File

@ -1,119 +0,0 @@
#include <iostream>
#include <climits>
#include <vector>
#include <stdio.h>
using namespace std;
#include <DFHack.h>
DFHack::Materials * Materials;
DFHack::VersionInfo *mem;
vector< vector<string> > englishWords;
vector< vector<string> > foreignWords;
int main (int numargs, char ** args)
{
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext();
DFHack::Process * p;
try
{
DF->Attach();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
p = DF->getProcess();
string check = "";
if(numargs == 2)
check = args[1];
DFHack::Creatures * Creatures = DF->getCreatures();
Materials = DF->getMaterials();
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;
}
if(!numCreatures)
{
cerr << "No creatures to print" << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
mem = DF->getMemoryInfo();
if(!Materials->ReadInorganicMaterials())
{
cerr << "Can't get the inorganics types." << endl;
return 1;
}
if(!Materials->ReadCreatureTypesEx())
{
cerr << "Can't get the creature types." << endl;
return 1;
}
if(!Tran->Start())
{
cerr << "Can't get name tables" << endl;
return 1;
}
vector<uint32_t> addrs;
//DF.InitViewAndCursor();
for(uint32_t i = 0; i < numCreatures; i++)
{
DFHack::t_creature temp;
unsigned int current_job;
unsigned int mat_start;
unsigned int mat_end;
unsigned int j,k;
unsigned int matptr;
Creatures->ReadCreature(i,temp);
if(temp.mood>=0)
{
current_job = p->readDWord(temp.origin + 0x390);
if(current_job == 0)
continue;
mat_start = p->readDWord(current_job + 0xa4 + 4*3);
mat_end = p->readDWord(current_job + 0xa4 + 4*4);
for(j=mat_start;j<mat_end;j+=4)
{
matptr = p->readDWord(j);
for(k=0;k<4;k++)
printf("%.4X ", p->readWord(matptr + k*2));
for(k=0;k<3;k++)
printf("%.8X ", p->readDWord(matptr + k*4 + 0x8));
for(k=0;k<2;k++)
printf("%.4X ", p->readWord(matptr + k*2 + 0x14));
for(k=0;k<3;k++)
printf("%.8X ", p->readDWord(matptr + k*4 + 0x18));
for(k=0;k<4;k++)
printf("%.2X ", p->readByte(matptr + k + 0x24));
for(k=0;k<6;k++)
printf("%.8X ", p->readDWord(matptr + k*4 + 0x28));
for(k=0;k<4;k++)
printf("%.2X ", p->readByte(matptr + k + 0x40));
for(k=0;k<9;k++)
printf("%.8X ", p->readDWord(matptr + k*4 + 0x44));
printf(" [%p]\n", matptr);
}
}
}
Creatures->Finish();
DF->Detach();
return 0;
}

31
tools/playground/paths.cpp
Unescape Escape View File

@ -1,31 +0,0 @@
#include <iostream>
using namespace std;
#include <DFHack.h>
using namespace DFHack;
int main ()
{
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext();
try
{
DF->Attach();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::Process * Process = DF->getProcess();
DFHack::Gui * gui = DF->getGui();
cout << Process->getPath() << endl;
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

27
tools/playground/primitives.cpp
Unescape Escape View File

@ -1,27 +0,0 @@
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
using namespace std;
std::string teststr1;
std::string * teststr2;
std::string teststr3("test");
int main (int numargs, const char ** args)
{
printf("std::string E : 0x%x\n", &teststr1);
teststr1 = "This is a fairly long string, much longer than the one made by default constructor.";
cin.ignore();
printf("std::string L : 0x%x\n", &teststr1);
teststr1 = "This one is shorter";
cin.ignore();
printf("std::string S : 0x%x\n", &teststr1);
cin.ignore();
teststr2 = new string();
printf("std::string * : 0x%x\n", &teststr2);
printf("std::string(\"test\") : 0x%x\n", &teststr3);
cin.ignore();
return 0;
}

100
tools/playground/printtiletypes.cpp
Unescape Escape View File

@ -1,100 +0,0 @@
// Prints all the Tile Types known by DFHack.
// File is both fixed-field and CSV parsable.
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <map>
#include <stddef.h>
#include <assert.h>
using namespace std;
#include <DFHack.h>
#include <DFTileTypes.h>
using namespace DFHack;
int main (int argc, char **argv)
{
FILE *f=stdout;
const int Columns = 7;
const char * Headings[Columns] = {"TileTypeID","Class","Material","V","Special","Direction","Description"};
size_t Size[ Columns ] = {};
int i;
//First, figure out column widths.
for(i=0;i<Columns;++i)
{
Size[i]=strlen(Headings[i])+1;
}
//Classes
fprintf(f,"\nTile Type Classes:\n");
for(i=0;i<tileshape_count;++i)
{
Size[1]=max<size_t>(Size[1],strlen(TileShapeString[i]));
fprintf(f,"%4i ; %s\n", i, TileShapeString[i] ,0 );
}
//Materials
fprintf(f,"\nTile Type Materials:\n");
for(i=0;i<tilematerial_count;++i)
{
Size[2]=max<size_t>(Size[2],strlen(TileMaterialString[i]));
fprintf(f,"%4i ; %s\n", i, TileMaterialString[i] ,0 );
}
//Specials
fprintf(f,"\nTile Type Specials:\n");
for(i=0;i<tilespecial_count;++i)
{
Size[4]=max<size_t>(Size[4],strlen(TileSpecialString[i]));
fprintf(f,"%4i ; %s\n", i, TileSpecialString[i] ,0 );
}
/* - Not needed for now -
//Direction is tricky
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
Size[5]=max(Size[5], tileTypeTable[i].d.sum()+1 );
*/
//Print the headings first.
fprintf(f,"\nTile Types:\n");
for(i=0;i<Columns;++i)
{
if(i) putc(';',f);
fprintf(f," %-*s ",Size[i],Headings[i],0);
}
fprintf(f,"\n");
//Process the whole array.
//A macro should be used for making the strings safe, but they are left in naked ? blocks
//to illustrate the array references more clearly.
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
{
fprintf(f," %*i ; %-*s ; %-*s ; %*c ; %-*s ; %-*s ; %s\n",
Size[0], i,
Size[1], ( tileTypeTable[i].name ? TileShapeString[ tileTypeTable[i].shape ] : "" ),
Size[2], ( tileTypeTable[i].name ? TileMaterialString[ tileTypeTable[i].material ] : "" ),
Size[3], ( tileTypeTable[i].variant ? '0'+tileTypeTable[i].variant : ' ' ),
Size[4], ( tileTypeTable[i].special ? TileSpecialString[ tileTypeTable[i].special ] : "" ),
Size[5], ( tileTypeTable[i].direction.whole ? tileTypeTable[i].direction.getStr() : "" ),
( tileTypeTable[i].name ? tileTypeTable[i].name : "" ),
0
);
}
fprintf(f,"\n");
#ifndef LINUX_BUILD
if( 1== argc)
{
cout << "Done. Press any key to continue" << endl;
cin.ignore();
}
#endif
return 0;
}

470
tools/playground/renamer.cpp
Unescape Escape View File

@ -1,470 +0,0 @@
// Creature dump
#include <iostream>
#include <sstream>
#include <climits>
#include <vector>
using namespace std;
#define DFHACK_WANT_MISCUTILS
#include <DFHack.h>
#include <modules/Materials.h>
#include <modules/Units.h>
#include <modules/Translation.h>
vector< vector<string> > englishWords;
vector< vector<string> > foreignWords;
uint32_t numCreatures;
vector<DFHack::t_matgloss> creaturestypes;
void printDwarves(DFHack::ContextManager & DF)
{
int dwarfCounter = 0;
DFHack::Creatures * c = DF.getCreatures();
for (uint32_t i = 0; i < numCreatures; i++)
{
DFHack::t_creature temp;
c->ReadCreature(i, temp);
string type = creaturestypes[temp.type].id;
if (type == "DWARF" && !temp.flags1.bits.dead && !temp.flags2.bits.killed)
{
cout << i << ":";
if (temp.name.nickname[0])
{
cout << temp.name.nickname;
}
else
{
cout << temp.name.first_name;
}
string transName = DF.TranslateName(temp.name,englishWords,foreignWords, false);
cout << " " << temp.custom_profession; //transName;
if (dwarfCounter%3 != 2)
{
cout << '\t';
}
else
{
cout << endl;
}
dwarfCounter++;
}
}
}
bool getDwarfSelection(DFHack::ContextManager & DF, DFHack::t_creature & toChange,string & changeString, string & commandString,int & eraseAmount,int &dwarfNum,bool &isName)
{
static string lastText;
bool dwarfSuccess = false;
while (!dwarfSuccess)
{
string input;
cout << "\nSelect Dwarf to Change or q to Quit" << endl;
DF.Resume();
getline (cin, input);
DF.Suspend();
if (input == "q")
{
return false;
}
else if (input == "r")
{
printDwarves(DF);
}
else if (!input.empty())
{
int num;
stringstream(input) >> num;//= atol(input.c_str());
dwarfSuccess = DF.ReadCreature(num,toChange);
string type = creaturestypes[toChange.type].id;
if (type != "DWARF")
{
dwarfSuccess = false;
}
else
{
dwarfNum = num;
}
}
}
bool changeType = false;
while (!changeType)
{
string input;
cout << "\n(n)ickname or (p)rofession?" << endl;
getline(cin, input);
if (input == "q")
{
return false;
}
if (input == "n")
{
commandString = "pzyn";
eraseAmount = string(toChange.name.nickname).length();
changeType = true;
isName = true;
}
else if (input == "p")
{
commandString = "pzyp";
eraseAmount = string(toChange.custom_profession).length();
changeType = true;
isName = false;
}
}
bool changeValue = false;
while (!changeValue)
{
string input;
cout << "value to change to?" << endl;
getline(cin, input);
if (input == "q")
{
return false;
}
if (!lastText.empty() && input.empty())
{
changeValue = true;
}
else if ( !input.empty())
{
lastText = input;
changeValue = true;
}
}
changeString = lastText;
return true;
}
bool waitTillChanged(DFHack::ContextManager &DF, int creatureToCheck, string changeValue, bool isName)
{
DFHack::DFWindow * w = DF.getWindow();
DF.Suspend();
DFHack::t_creature testCre;
DF.ReadCreature(creatureToCheck,testCre);
int tryCount = 0;
if (isName)
{
while (testCre.name.nickname != changeValue && tryCount <50)
{
DF.Resume();
w->TypeSpecial(DFHack::WAIT,1,100);
DF.Suspend();
DF.ReadCreature(creatureToCheck,testCre);
tryCount++;
}
}
else
{
while (testCre.custom_profession != changeValue && tryCount < 50)
{
DF.Resume();
w->TypeSpecial(DFHack::WAIT,1,100);
DF.Suspend();
DF.ReadCreature(creatureToCheck,testCre);
tryCount++;
}
}
if (tryCount >= 50)
{
cerr << "Something went wrong, make sure that DF is at the correct screen";
return false;
}
DF.Resume();
return true;
}
bool waitTillScreenState(DFHack::ContextManager &DF, string screenState,bool EqualTo=true)
{
DFHack::DFWindow * w = DF.getWindow();
DFHack::t_viewscreen current;
DF.Suspend();
DF.ReadViewScreen(current);
string nowScreenState;
DF.getMemoryInfo()->resolveClassIDToClassname(current.type,nowScreenState);
int tryCount = 0;
while (((EqualTo && nowScreenState != screenState) || (!EqualTo && nowScreenState == screenState)) && tryCount < 50)
{
DF.Resume();
w->TypeSpecial(DFHack::WAIT,1,100);
DF.Suspend();
DF.ReadViewScreen(current);
tryCount++;
}
if (tryCount >= 50) {
cerr << "Something went wrong, DF at " << nowScreenState << endl;
return false;
}
DF.Resume();
return true;
}
bool waitTillCursorState(DFHack::ContextManager &DF, bool On)
{
DFHack::DFWindow * w = DF.getWindow();
int32_t x,y,z;
int tryCount = 0;
DF.Suspend();
bool cursorResult = DF.getCursorCoords(x,y,z);
while (tryCount < 50 && On && !cursorResult || !On && cursorResult)
{
DF.Resume();
w->TypeSpecial(DFHack::WAIT,1,100);
tryCount++;
DF.Suspend();
cursorResult = DF.getCursorCoords(x,y,z);
}
if (tryCount >= 50)
{
cerr << "Something went wrong, cursor at x: " << x << " y: " << y << " z: " << z << endl;
return false;
}
DF.Resume();
return true;
}
bool waitTillMenuState(DFHack::ContextManager &DF, uint32_t menuState,bool EqualTo=true)
{
int tryCount = 0;
DFHack::DFWindow * w = DF.getWindow();
DF.Suspend();
uint32_t testState = DF.ReadMenuState();
while (tryCount < 50 && ((EqualTo && menuState != testState) || (!EqualTo && menuState == testState)))
{
DF.Resume();
w->TypeSpecial(DFHack::WAIT,1,100);
tryCount++;
DF.Suspend();
testState = DF.ReadMenuState();
}
if (tryCount >= 50)
{
cerr << "Something went wrong, menuState: "<<testState << endl;
return false;
}
DF.Resume();
return true;
}
bool moveToBaseWindow(DFHack::ContextManager &DF)
{
DFHack::DFWindow * w = DF.getWindow();
DFHack::t_viewscreen current;
DF.ReadViewScreen(current);
string classname;
DF.getMemoryInfo()->resolveClassIDToClassname(current.type,classname);
while (classname != "viewscreen_dwarfmode")
{
w->TypeSpecial(DFHack::F9); // cancel out of text input in names
// DF.TypeSpecial(DFHack::ENTER); // cancel out of text input in hotkeys
w->TypeSpecial(DFHack::SPACE); // should move up a level
if (!waitTillScreenState(DF,classname,false)) return false; // wait until screen changes from current
DF.ReadViewScreen(current);
DF.getMemoryInfo()->resolveClassIDToClassname(current.type,classname);
}
if (DF.ReadMenuState() != 0) {// if menu state != 0 then there is a menu, so escape it
w->TypeSpecial(DFHack::F9);
w->TypeSpecial(DFHack::ENTER); // exit out of any text prompts
w->TypeSpecial(DFHack::SPACE); // go back to base state
if (!waitTillMenuState(DF,0))return false;
}
DF.Resume();
return true;
}
bool setCursorToCreature(DFHack::ContextManager &DF)
{
DFHack::DFWindow * w = DF.getWindow();
int32_t x,y,z;
DF.Suspend();
DF.getCursorCoords(x,y,z);
DF.Resume();
if (x == -30000) {
w->TypeStr("v");
if (!waitTillCursorState(DF,true)) return false;
}
else { // reset the cursor to be the creature cursor
w->TypeSpecial(DFHack::SPACE);
if (!waitTillCursorState(DF,false)) return false;
w->TypeStr("v");
if (!waitTillCursorState(DF,true)) return false;
}
return true;
}
int main (void)
{
DFHack::ContextManager DF("Memory.xml");
DFHack::Creatures *c;
DFHack::Materials *m;
try
{
DF.Attach();
c = DF.getCreatures();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::memory_info * mem = DF.getMemoryInfo();
if (!m->ReadCreatureTypes(creaturestypes))
{
cerr << "Can't get the creature types." << endl;
return 1;
}
DF.InitReadNameTables(englishWords,foreignWords);
c->Start(numCreatures);
// DF.InitViewAndCursor();
DFHack::Process * p = DF.getProcess();
DFHack::DFWindow * w = DF.getWindow();
DFHack::t_creature toChange;
string changeString,commandString;
int eraseAmount;
int toChangeNum;
bool isName;
bool useKeys = true;
string input2;
// use key event emulation or direct writing?
cout << "\nUse \n1:Key simulation\n2:Direct Writing" << endl;
getline(cin,input2);
if (input2 == "1")
{
useKeys = true;
}
else {
useKeys = false;
}
printDwarves(DF);
while (getDwarfSelection(DF,toChange,changeString,commandString,eraseAmount,toChangeNum,isName))
{
// limit length, DF doesn't accept input after this point
if (changeString.size() > 39)
{
changeString.resize(39);
}
start:
bool completed = false;
if (useKeys) {
if (moveToBaseWindow(DF) && setCursorToCreature(DF))
{
DF.Suspend();
DF.setCursorCoords(toChange.x, toChange.y,toChange.z);
uint32_t underCursor;
DF.getCurrentCursorCreature(underCursor);
while (underCursor != toChangeNum)
{
DF.Resume();
w->TypeStr("v",100);
DF.Suspend();
DF.setCursorCoords(toChange.x, toChange.y,toChange.z);
DF.ReadCreature(toChangeNum,toChange);
DF.getCurrentCursorCreature(underCursor);
}
/*//CurrentCursorCreatures gives the creatures in the order that you see them with the 'k' cursor.
//The 'v' cursor displays them in the order of last, then first,second,third and so on
//Pretty weird, but it works
//The only place that seems to display which creature is currently selected is on the stack, whose location is likely not static, so not usable
if (underCursor[underCursor.size()-1] != toChange.origin)
{
for (int i = 0;i<underCursor.size()-1;i++)
{
DF.Resume();
w->TypeStr("v",100);
if (underCursor[i] == toChange.origin)
{
break;
}
}
}*/
DF.Resume();
w->TypeStr(commandString.c_str());
if (waitTillScreenState(DF,"viewscreen_customize_unit"))
{
DF.Resume();
w->TypeSpecial(DFHack::BACK_SPACE,eraseAmount);
if (waitTillChanged(DF,toChangeNum,"",isName))
{
DF.Resume();
w->TypeStr(changeString.c_str());
if (waitTillChanged(DF,toChangeNum,changeString,isName))
{
DF.Resume();
w->TypeSpecial(DFHack::ENTER);
w->TypeSpecial(DFHack::SPACE); // should take you to unit screen if everything worked
if (waitTillScreenState(DF,"viewscreen_unit"))
{
DF.Resume();
w->TypeSpecial(DFHack::SPACE);
if (waitTillScreenState(DF,"viewscreen_dwarfmode"))
{
DF.Resume();
w->TypeSpecial(DFHack::SPACE);
if (waitTillCursorState(DF,false))
{
completed = true;
}
}
}
}
}
}
}
if (!completed) {
cerr << "Something went wrong, please reset DF to its original state, then press any key to continue" << endl;
goto start;
}
}
else
{
// will only work with the shm probably should check for it, but I don't know how,
// I have the writeString function do nothing for normal mode
if (commandString == "pzyn") // change nickname
{
try
{
uint32_t nickname = mem->getOffset("creature_name") + mem->getOffset("name_nickname");
p->writeSTLString(toChange.origin+nickname,changeString);
}
catch (DFHack::Error::AllMemdef&)
{
cerr << "Writing creature nicknames unsupported in this version!" << endl;
}
}
else
{
try
{
uint32_t custom_prof = mem->getOffset("creature_custom_profession");
p->writeSTLString(toChange.origin+custom_prof,changeString);
}
catch (DFHack::Error::AllMemdef&)
{
cerr << "Writing creature custom profession unsupported in this version!" << endl;
}
}
}
DF.Suspend();
printDwarves(DF);
}
return 0;
}

58
tools/playground/test.c
Unescape Escape View File

@ -1,58 +0,0 @@
#include <limits.h>
#include <time.h>
#include <stdio.h>
#include <DFHack_C.h>
#include <dfhack-c/DFTypes_C.h>
#include <dfhack-c/DFContext_C.h>
#include <dfhack-c/modules/Maps_C.h>
int main (int numargs, const char ** args)
{
printf("From C: ");
DFHackObject* cman = ContextManager_Alloc("Memory.xml");
DFHackObject* context = ContextManager_getSingleContext(cman);
if(context)
{
Context_Attach(context);
DFHackObject * maps = Context_getMaps(context);
if(maps)
{
Maps_Start(maps);
uint32_t x,y,z;
Maps_getSize(maps, &x, &y, &z);
printf("Map size: %d, %d, %d\n", x,y,z);
}
}
ContextManager_Free(cman);
cout << "From C++:";
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;
}
// DO STUFF HERE
Maps * m = DF->getMaps();
m->Start();
uint32_t x,y,z;
m->getSize(x,y,z);
cout << "Map size " << x << ", "<< y << ", " << z << endl;
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

43
tools/playground/typeblocks.cpp
Unescape Escape View File

@ -1,43 +0,0 @@
#include <iostream>
#include <iomanip>
#include <climits>
#include <vector>
#include <sstream>
#include <ctime>
#include <cstdio>
using namespace std;
#include <DFHack.h>
using namespace DFHack;
namespace TBlocks
{
}
int main (int numargs, const char ** args)
{
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;
}
// DO STUFF HERE
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}