DFhackCExport command_result df_drybuckets (Core * c, vector <string> & parameters)
{
if(parameters.size() > 0)
{
string & p = parameters[0];
if(p == "?" || p == "help")
{
c->con.print("This utility removes all objects of type LIQUID_MISC:NONE and material WATER:NONE - that is, water stored in buckets.\n");
return CR_OK;
}
}
c->Suspend();
DFHack::Items * Items = c->getItems();
vector <df_item *> p_items;
if(!Items->readItemVector(p_items))
{
c->con.printerr("Can't access the item vector.\n");
c->Resume();
return CR_FAILURE;
}
std::size_t numItems = p_items.size();
int dried_total = 0;
for (std::size_t i = 0; i < numItems; i++)
{
df_item *item = p_items[i];
if ((item->getType() == Items::LIQUID_MISC) && (item->getMaterial() == Materials::WATER))
{
item->flags.garbage_colect = 1;
dried_total++;
}
}
c->Resume();
c->con.print("Done. %d buckets of water emptied.\n", dried_total);
return CR_OK;
}
DFhackCExport command_result df_cleanowned (Core * c, vector <string> & parameters)
{
bool dump_scattered = false;
bool confiscate_all = false;
bool dry_run = false;
int wear_dump_level = 65536;
for(std::size_t i = 0; i < parameters.size(); i++)
{
string & param = parameters[i];
if(param == "dryrun")
dry_run = true;
else if(param == "scattered")
dump_scattered = true;
else if(param == "all")
confiscate_all = true;
else if(param == "x")
wear_dump_level = 1;
else if(param == "X")
wear_dump_level = 2;
else if(param == "?" || param == "help")
{
c->con.print("This tool lets you confiscate and dump all the garbage\n"
"dwarves ultimately accumulate.\n"
"By default, only rotten and dropped food is confiscated.\n"
"Options:\n"
" dryrun - don't actually do anything, just print what would be done.\n"
" scattered - confiscate owned items on the ground\n"
" all - confiscate everything\n"
" x - confiscate & dump 'x' and worse damaged items\n"
" X - confiscate & dump 'X' and worse damaged items\n"
" ? - this help\n"
"Example:\n"
" confiscate scattered X\n"
" This will confiscate rotten and dropped food, garbage on the floors\n"
" and any worn items wit 'X' damage and above.\n"
);
return CR_OK;
}
else
{
c->con.printerr("Parameter '%s' is not valid. See 'cleanowned help'.\n",param.c_str());
return CR_FAILURE;
}
}
c->Suspend();
DFHack::Materials *Materials = c->getMaterials();
DFHack::Items *Items = c->getItems();
DFHack::Units *Creatures = c->getUnits();
DFHack::Translation *Tran = c->getTranslation();
uint32_t num_creatures;
bool ok = true;
ok &= Materials->ReadAllMaterials();
ok &= Creatures->Start(num_creatures);
ok &= Tran->Start();
vector<df_item *> p_items;
ok &= Items->readItemVector(p_items);
if(!ok)
{
c->con.printerr("Can't continue due to offset errors.\n");
c->Resume();
return CR_FAILURE;
}
c->con.print("Found total %d items.\n", p_items.size());
for (std::size_t i=0; i < p_items.size(); i++)
{
df_item * item = p_items[i];
bool confiscate = false;
bool dump = false;
if (!item->flags.owned)
{
int32_t owner = Items->getItemOwnerID(item);
if (owner >= 0)
{
c->con.print("Fixing a misflagged item: \t");
confiscate = true;
}
else
{
continue;
}
}
std::string name = Items->getItemClass(item);
if (item->flags.rotten)
{
c->con.print("Confiscating a rotten item: \t");
confiscate = true;
}
else if (item->flags.on_ground)
{
int32_t type = item->getType();
if(type == Items::MEAT ||
type == Items::FISH ||
type == Items::VERMIN ||
type == Items::PET ||
type == Items::PLANT ||
type == Items::CHEESE ||
type == Items::FOOD
)
{
confiscate = true;
if(dump_scattered)
{
c->con.print("Dumping a dropped item: \t");
dump = true;
}
else
{
c->con.print("Confiscating a dropped item: \t");
}
}
else if(dump_scattered)
{
c->con.print("Confiscating and dumping litter: \t");
confiscate = true;
dump = true;
}
}
else if (item->getWear() >= wear_dump_level)
{
c->con.print("Confiscating and dumping a worn item: \t");
confiscate = true;
dump = true;
}
else if (confiscate_all)
{
c->con.print("Confiscating: \t");
confiscate = true;
}
if (confiscate)
{
std::string description;
item->getItemDescription(&description, 0);
c->con.print(
"0x%x %s (wear %d)",
item,
description.c_str(),
item->getWear()
);
int32_t owner = Items->getItemOwnerID(item);
int32_t owner_index = Creatures->FindIndexById(owner);
std::string info;
if (owner_index >= 0)
{
DFHack::df_unit * temp = Creatures->GetCreature(owner_index);
info = temp->name.first_name;
if (!temp->name.nick_name.empty())
info += std::string(" '") + temp->name.nick_name + "'";
info += " ";
info += Tran->TranslateName(&temp->name,false);
c->con.print(", owner %s", info.c_str());
}
if (!dry_run)
{
if (!Items->removeItemOwner(item, Creatures))
c->con.print("(unsuccessfully) ");
if (dump)
item->flags.dump = 1;
}
c->con.print("\n");
}
}
c->Resume();
return CR_OK;
}
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;
}
static command_result autodump_main(Core * c, vector <string> & parameters)
{
// Command line options
bool destroy = false;
bool here = false;
if(parameters.size() > 0)
{
string & p = parameters[0];
if(p == "destroy")
destroy = true;
else if (p == "destroy-here")
destroy = here = true;
else if(p == "?" || p == "help")
{
c->con.print(
"This utility lets you quickly move all items designated to be dumped.\n"
"Items are instantly moved to the cursor position, the dump flag is unset,\n"
"and the forbid flag is set, as if it had been dumped normally.\n"
"Be aware that any active dump item tasks still point at the item.\n\n"
"Options:\n"
"destroy - instead of dumping, destroy the items instantly.\n"
"destroy-here - only affect the tile under cursor.\n"
);
return CR_OK;
}
}
c->Suspend();
DFHack::VersionInfo *mem = c->vinfo;
DFHack::Gui * Gui = c->getGui();
DFHack::Items * Items = c->getItems();
DFHack::Maps *Maps = c->getMaps();
vector <df_item*> p_items;
if(!Items->readItemVector(p_items))
{
c->con.printerr("Can't access the item vector.\n");
return CR_FAILURE;
}
std::size_t numItems = p_items.size();
// init the map
if(!Maps->Start())
{
c->con.printerr("Can't initialize map.\n");
return CR_FAILURE;
}
MapCache MC (Maps);
int i = 0;
int dumped_total = 0;
int cx, cy, cz;
DFCoord pos_cursor;
if(!destroy || here)
{
if (!Gui->getCursorCoords(cx,cy,cz))
{
c->con.printerr("Cursor position not found. Please enabled the cursor.\n");
return CR_FAILURE;
}
pos_cursor = DFCoord(cx,cy,cz);
}
if (!destroy)
{
{
Block * b = MC.BlockAt(pos_cursor / 16);
if(!b)
{
c->con.printerr("Cursor is in an invalid/uninitialized area. Place it over a floor.\n");
return CR_FAILURE;
}
uint16_t ttype = MC.tiletypeAt(pos_cursor);
if(!DFHack::isFloorTerrain(ttype))
{
c->con.printerr("Cursor should be placed over a floor.\n");
return CR_FAILURE;
}
}
}
coordmap counts;
// proceed with the dumpification operation
for(std::size_t i=0; i< numItems; i++)
{
df_item * itm = p_items[i];
DFCoord pos_item(itm->x, itm->y, itm->z);
// keep track how many items are at places. all items.
coordmap::iterator it = counts.find(pos_item);
if(it == counts.end())
{
std::pair< coordmap::iterator, bool > inserted = counts.insert(std::make_pair(pos_item,1));
it = inserted.first;
}
else
{
it->second ++;
}
// iterator is valid here, we use it later to decrement the pile counter if the item is moved
// only dump the stuff marked for dumping and laying on the ground
if ( !itm->flags.dump
|| !itm->flags.on_ground
|| itm->flags.construction
|| itm->flags.hidden
|| itm->flags.in_building
|| itm->flags.in_chest
|| itm->flags.in_inventory
|| itm->flags.artifact1
)
continue;
if(!destroy) // move to cursor
{
// Change flags to indicate the dump was completed, as if by super-dwarfs
itm->flags.dump = false;
itm->flags.forbid = true;
// Don't move items if they're already at the cursor
if (pos_cursor == pos_item)
continue;
// Do we need to fix block-local item ID vector?
if(pos_item/16 != pos_cursor/16)
{
// yes...
cerr << "Moving from block to block!" << endl;
df_block * bl_src = Maps->getBlock(itm->x /16, itm->y/16, itm->z);
df_block * bl_tgt = Maps->getBlock(cx /16, cy/16, cz);
if(bl_src)
{
std::remove(bl_src->items.begin(), bl_src->items.end(),itm->id);
}
else
{
cerr << "No source block" << endl;
}
if(bl_tgt)
{
bl_tgt->items.push_back(itm->id);
}
else
{
cerr << "No target block" << endl;
}
}
// Move the item
itm->x = pos_cursor.x;
itm->y = pos_cursor.y;
itm->z = pos_cursor.z;
}
else // destroy
{
if (here && pos_item != pos_cursor)
continue;
itm->flags.garbage_colect = true;
// Cosmetic changes: make them disappear from view instantly
itm->flags.forbid = true;
itm->flags.hidden = true;
}
// keeping track of item pile sizes ;)
it->second --;
dumped_total++;
}
if(!destroy) // TODO: do we have to do any of this when destroying items?
{
// for each item pile, see if it reached zero. if so, unset item flag on the tile it's on
coordmap::iterator it = counts.begin();
coordmap::iterator end = counts.end();
while(it != end)
{
if(it->second == 0)
{
t_occupancy occ = MC.occupancyAt(it->first);
occ.bits.item = false;
MC.setOccupancyAt(it->first, occ);
}
it++;
}
// Set "item here" flag on target tile, if we moved any items to the target tile.
if (dumped_total > 0)
{
// assume there is a possibility the cursor points at some weird location with missing block data
Block * b = MC.BlockAt(pos_cursor / 16);
if(b)
{
t_occupancy occ = MC.occupancyAt(pos_cursor);
occ.bits.item = 1;
MC.setOccupancyAt(pos_cursor,occ);
}
}
// write map changes back to DF.
MC.WriteAll();
// Is this necessary? Is "forbid" a dirtyable attribute like "dig" is?
Maps->WriteDirtyBit(cx/16, cy/16, cz, true);
}
c->con.print("Done. %d items %s.\n", dumped_total, destroy ? "marked for desctruction" : "quickdumped");
return CR_OK;
}
