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

Make seedwatch work on linux, still with ugly hacks.

develop
Petr Mrázek 2011-10-27 03:31:13 +02:00
parent 8838d8c3d6
commit 61be3413e3
2 changed files with 451 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
library/include/dfhack/modules/Items.h
Unescape Escape View File

@ -107,7 +107,12 @@ struct t_itemref : public t_virtual
struct df_contaminant struct df_contaminant
{ {
// fixme: figure it out int16_t material;
int32_t mat_index;
int16_t mat_state; // FIXME: enum or document in text
int16_t temperature;
int16_t temperature_fraction; // maybe...
int32_t size; ///< 1-24=spatter, 25-49=smear, 50-* = coating
}; };
/** /**
@ -146,6 +151,10 @@ public:
int32_t mystery5; int32_t mystery5;
// 5C L, 64 W - pointer to vector of contaminants // 5C L, 64 W - pointer to vector of contaminants
std::vector <df_contaminant *> * contaminants; std::vector <df_contaminant *> * contaminants;
// 60 L, 6C W - temperature in Urists
int16_t temperature;
// 62 L, 6E W - temperature fraction (maybe, just a guess)
int16_t temperature_fraction;
public: public:
// 0x0 // 0x0
virtual int32_t getType(); virtual int32_t getType();

190
plugins/seedwatch.cpp
Unescape Escape View File

@ -13,15 +13,13 @@
#include "dfhack/modules/Materials.h" #include "dfhack/modules/Materials.h"
typedef int32_t t_materialIndex; typedef int32_t t_materialIndex;
typedef int16_t t_materialSubindex, t_itemType, t_itemSubtype; typedef int16_t t_material, t_itemType, t_itemSubtype;
typedef int8_t t_exclusionType; typedef int8_t t_exclusionType;
const unsigned int seedLimit = 400; // a limit on the limits which can be placed on seeds const unsigned int seedLimit = 400; // a limit on the limits which can be placed on seeds
const t_itemType seedType = 52; // from df.magmawiki.com/index.php/Item_token
const t_itemType plantType = 53; // from df.magmawiki.com/index.php/Item_token
const t_itemSubtype organicSubtype = -1; // seems to fixed const t_itemSubtype organicSubtype = -1; // seems to fixed
const t_exclusionType cookingExclusion = 1; // seems to be fixed const t_exclusionType cookingExclusion = 1; // seems to be fixed
const t_itemType limitType = 0; // used to store limit as an entry in the exclusion list const t_itemType limitType = 0; // used to store limit as an entry in the exclusion list. 0 = BAR
const t_itemSubtype limitSubtype = 0; // used to store limit as an entry in the exclusion list const t_itemSubtype limitSubtype = 0; // used to store limit as an entry in the exclusion list
const t_exclusionType limitExclusion = 4; // used to store limit as an entry in the exclusion list const t_exclusionType limitExclusion = 4; // used to store limit as an entry in the exclusion list
const int buffer = 20; // seed number buffer - 20 is reasonable const int buffer = 20; // seed number buffer - 20 is reasonable
@ -43,27 +41,27 @@ bool ignoreSeeds(DFHack::t_itemflags& f) // seeds with the following flags shoul
f.in_building || f.in_building ||
f.in_job; f.in_job;
}; };
void updateCountAndSubindices(DFHack::Core& core, std::map<t_materialIndex, unsigned int>& seedCount, std::map<t_materialIndex, t_materialSubindex>& seedSubindices, std::map<t_materialIndex, t_materialSubindex>& plantSubindices) // fills seedCount, seedSubindices and plantSubindices void updateCountAndSubindices(DFHack::Core& core, std::map<t_materialIndex, unsigned int>& seedCount, std::map<t_materialIndex, t_material>& seedSubindices, std::map<t_materialIndex, t_material>& plantSubindices) // fills seedCount, seedSubindices and plantSubindices
{ {
DFHack::Items& itemsModule = *core.getItems(); DFHack::Items& itemsModule = *core.getItems();
itemsModule.Start(); itemsModule.Start();
std::vector<DFHack::t_item*> items; std::vector<DFHack::df_item*> items;
itemsModule.readItemVector(items); itemsModule.readItemVector(items);
DFHack::dfh_item item; DFHack::df_item * item;
std::size_t size = items.size(); std::size_t size = items.size();
for(std::size_t i = 0; i < size; ++i) for(std::size_t i = 0; i < size; ++i)
{ {
itemsModule.readItem(items[i], item); item = items[i];
t_materialIndex materialIndex = item.matdesc.index; t_materialIndex materialIndex = item->getMaterialIndex();
switch(item.matdesc.itemType) switch(item->getType())
{ {
case seedType: case DFHack::Items::SEEDS:
seedSubindices[materialIndex] = item.matdesc.subIndex; seedSubindices[materialIndex] = item->getMaterial();
if(!ignoreSeeds(item.base->flags)) ++seedCount[materialIndex]; if(!ignoreSeeds(item->flags)) ++seedCount[materialIndex];
break; break;
case plantType: case DFHack::Items::PLANT:
plantSubindices[materialIndex] = item.matdesc.subIndex; plantSubindices[materialIndex] = item->getMaterial();
break; break;
} }
} }
@ -72,12 +70,13 @@ void updateCountAndSubindices(DFHack::Core& core, std::map<t_materialIndex, unsi
}; };
void printHelp(DFHack::Core& core) // prints help void printHelp(DFHack::Core& core) // prints help
{ {
core.con.print("\ne.g. #seedwatch MUSHROOM_HELMET_PLUMP 30\n"); core.con.print(
core.con.print("This is how to add an item to the watch list.\n"); "\ne.g. #seedwatch MUSHROOM_HELMET_PLUMP 30\n"
core.con.print("MUSHROOM_HELMET_PLUMP is the plant token for plump helmets (found in raws)\n"); "This is how to add an item to the watch list.\n"
core.con.print("The number of available plump helmet seeds is counted each tick\n"); "MUSHROOM_HELMET_PLUMP is the plant token for plump helmets (found in raws)\n"
core.con.print("If it falls below 30, plump helmets and plump helmet seeds will be excluded from cookery.\n"); "The number of available plump helmet seeds is counted each tick\n"
core.con.print("%i is the buffer, therefore if the number rises above 30 + %i, then cooking will be allowed.\n", buffer, buffer); "If it falls below 30, plump helmets and plump helmet seeds will be excluded from cookery.\n"
"%i is the buffer, therefore if the number rises above 30 + %i, then cooking will be allowed.\n", buffer, buffer);
if(!abbreviations.empty()) if(!abbreviations.empty())
{ {
core.con.print("You can use these abbreviations for the plant tokens:\n"); core.con.print("You can use these abbreviations for the plant tokens:\n");
@ -86,31 +85,42 @@ void printHelp(DFHack::Core& core) // prints help
core.con.print("%s -> %s\n", i->first.c_str(), i->second.c_str()); core.con.print("%s -> %s\n", i->first.c_str(), i->second.c_str());
} }
} }
core.con.print("e.g. #seedwatch ph 30\nis the same as #seedwatch MUSHROOM_HELMET_PLUMP 30\n\n"); core.con.print(
core.con.print("e.g. #seedwatch all 30\nAdds all which are in the abbreviation list to the watch list, the limit being 30.\n\n"); "e.g. #seedwatch ph 30\nis the same as #seedwatch MUSHROOM_HELMET_PLUMP 30\n\n"
core.con.print("e.g. #seedwatch MUSHROOM_HELMET_PLUMP\nRemoves MUSHROOM_HELMET_PLUMP from the watch list.\n\n"); "e.g. #seedwatch all 30\nAdds all which are in the abbreviation list to the watch list, the limit being 30.\n\n"
core.con.print("#seedwatch all\nClears the watch list.\n\n"); "e.g. #seedwatch MUSHROOM_HELMET_PLUMP\nRemoves MUSHROOM_HELMET_PLUMP from the watch list.\n\n"
core.con.print("#seedwatch start\nStart seedwatch watch.\n\n"); "#seedwatch all\nClears the watch list.\n\n"
core.con.print("#seedwatch stop\nStop seedwatch watch.\n\n"); "#seedwatch start\nStart seedwatch watch.\n\n"
core.con.print("#seedwatch info\nDisplay whether seedwatch is watching, and the watch list.\n\n"); "#seedwatch stop\nStop seedwatch watch.\n\n"
core.con.print("#seedwatch clear\nClears the watch list.\n"); "#seedwatch info\nDisplay whether seedwatch is watching, and the watch list.\n\n"
"#seedwatch clear\nClears the watch list.\n"
);
}; };
std::string searchAbbreviations(std::string in) // searches abbreviations, returns expansion if so, returns original if not
// searches abbreviations, returns expansion if so, returns original if not
std::string searchAbbreviations(std::string in)
{ {
if(abbreviations.count(in) > 0) return abbreviations[in]; if(abbreviations.count(in) > 0)
{
return abbreviations[in];
}
else
{
return in; return in;
}
}; };
class t_kitchenExclusions // helps to organise access to the cooking exclusions // helps to organise access to the cooking exclusions
class t_kitchenExclusions
{ {
public: public:
t_kitchenExclusions(DFHack::Core& core_) // constructor t_kitchenExclusions(DFHack::Core& core_) // constructor
: core(core_) : core(core_)
, itemTypes (*((std::vector<t_itemType >*)(start(core_) ))) // using the kludge in start , itemTypes (*((std::vector<t_itemType >*)(addr(core_,0))))
, itemSubtypes (*((std::vector<t_itemSubtype >*)(start(core_) + 0x10))) // further kludge offset , itemSubtypes (*((std::vector<t_itemSubtype >*)(addr(core_,1))))
, materialSubindices(*((std::vector<t_materialSubindex>*)(start(core_) + 0x20))) // further kludge offset , materials (*((std::vector<t_material >*)(addr(core_,2))))
, materialIndices (*((std::vector<t_materialIndex >*)(start(core_) + 0x30))) // further kludge offset , materialIndices (*((std::vector<t_materialIndex>*)(addr(core_,3))))
, exclusionTypes (*((std::vector<t_exclusionType >*)(start(core_) + 0x40))) // further kludge offset , exclusionTypes (*((std::vector<t_exclusionType>*)(addr(core_,4))))
{ {
}; };
void print() // print the exclusion list, with the material index also translated into its token (for organics) - for debug really void print() // print the exclusion list, with the material index also translated into its token (for organics) - for debug really
@ -120,7 +130,7 @@ public:
materialsModule.ReadOrganicMaterials(); materialsModule.ReadOrganicMaterials();
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
core.con.print("%2u: IT:%2i IS:%i MI:%2i MS:%3i ET:%i %s\n", i, itemTypes[i], itemSubtypes[i], materialIndices[i], materialSubindices[i], exclusionTypes[i], materialsModule.organic[materialIndices[i]].id.c_str()); core.con.print("%2u: IT:%2i IS:%i MI:%2i MS:%3i ET:%i %s\n", i, itemTypes[i], itemSubtypes[i], materialIndices[i], materials[i], exclusionTypes[i], materialsModule.organic[materialIndices[i]].id.c_str());
} }
core.con.print("\n"); core.con.print("\n");
}; };
@ -133,7 +143,10 @@ public:
std::size_t matchIndex = 0; std::size_t matchIndex = 0;
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(materialIndices[i] == materialIndex && (itemTypes[i] == seedType || itemTypes[i] == plantType) && exclusionTypes[i] == cookingExclusion) if(materialIndices[i] == materialIndex
&& (itemTypes[i] == DFHack::Items::SEEDS || itemTypes[i] == DFHack::Items::PLANT)
&& exclusionTypes[i] == cookingExclusion
)
{ {
match = true; match = true;
matchIndex = i; matchIndex = i;
@ -144,64 +157,74 @@ public:
itemTypes.erase(itemTypes.begin() + matchIndex); itemTypes.erase(itemTypes.begin() + matchIndex);
itemSubtypes.erase(itemSubtypes.begin() + matchIndex); itemSubtypes.erase(itemSubtypes.begin() + matchIndex);
materialIndices.erase(materialIndices.begin() + matchIndex); materialIndices.erase(materialIndices.begin() + matchIndex);
materialSubindices.erase(materialSubindices.begin() + matchIndex); materials.erase( materials.begin() + matchIndex);
exclusionTypes.erase(exclusionTypes.begin() + matchIndex); exclusionTypes.erase(exclusionTypes.begin() + matchIndex);
} }
} while(match); } while(match);
}; };
void denyCookery(t_materialIndex materialIndex, std::map<t_materialIndex, t_materialSubindex>& seedSubindices, std::map<t_materialIndex, t_materialSubindex>& plantSubindices) // add this material to the exclusion list, if it is not already in it
// add this material to the exclusion list, if it is not already in it
void denyCookery(t_materialIndex materialIndex, std::map<t_materialIndex, t_material>& seedMaterials, std::map<t_materialIndex, t_material>& plantMaterials)
{ {
if(seedSubindices.count(materialIndex) > 0) if( seedMaterials.count(materialIndex) > 0)
{ {
bool alreadyIn = false; bool alreadyIn = false;
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(materialIndices[i] == materialIndex && itemTypes[i] == seedType && exclusionTypes[i] == cookingExclusion) if(materialIndices[i] == materialIndex
&& itemTypes[i] == DFHack::Items::SEEDS
&& exclusionTypes[i] == cookingExclusion)
{ {
alreadyIn = true; alreadyIn = true;
} }
} }
if(!alreadyIn) if(!alreadyIn)
{ {
itemTypes.push_back(seedType); itemTypes.push_back(DFHack::Items::SEEDS);
itemSubtypes.push_back(organicSubtype); itemSubtypes.push_back(organicSubtype);
materials.push_back( seedMaterials[materialIndex]);
materialIndices.push_back(materialIndex); materialIndices.push_back(materialIndex);
materialSubindices.push_back(seedSubindices[materialIndex]);
exclusionTypes.push_back(cookingExclusion); exclusionTypes.push_back(cookingExclusion);
} }
} }
if(plantSubindices.count(materialIndex) > 0) if( plantMaterials.count(materialIndex) > 0)
{ {
bool alreadyIn = false; bool alreadyIn = false;
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(materialIndices[i] == materialIndex && itemTypes[i] == plantType && exclusionTypes[i] == cookingExclusion) if(materialIndices[i] == materialIndex
&& itemTypes[i] == DFHack::Items::PLANT
&& exclusionTypes[i] == cookingExclusion)
{ {
alreadyIn = true; alreadyIn = true;
} }
} }
if(!alreadyIn) if(!alreadyIn)
{ {
itemTypes.push_back(plantType); itemTypes.push_back(DFHack::Items::PLANT);
itemSubtypes.push_back(organicSubtype); itemSubtypes.push_back(organicSubtype);
materials.push_back(plantMaterials[materialIndex]);
materialIndices.push_back(materialIndex); materialIndices.push_back(materialIndex);
materialSubindices.push_back(plantSubindices[materialIndex]);
exclusionTypes.push_back(cookingExclusion); exclusionTypes.push_back(cookingExclusion);
} }
} }
}; };
void fillWatchMap(std::map<t_materialIndex, unsigned int>& watchMap) // fills a map with info from the limit info storage entries in the exclusion list
// fills a map with info from the limit info storage entries in the exclusion list
void fillWatchMap(std::map<t_materialIndex, unsigned int>& watchMap)
{ {
watchMap.clear(); watchMap.clear();
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(itemTypes[i] == limitType && itemSubtypes[i] == limitSubtype && exclusionTypes[i] == limitExclusion) if(itemTypes[i] == limitType && itemSubtypes[i] == limitSubtype && exclusionTypes[i] == limitExclusion)
{ {
watchMap[materialIndices[i]] = (unsigned int) materialSubindices[i]; watchMap[materialIndices[i]] = (unsigned int) materials[i];
} }
} }
}; };
void removeLimit(t_materialIndex materialIndex) // removes a limit info storage entry from the exclusion list if it is in it
// removes a limit info storage entry from the exclusion list if it is in it
void removeLimit(t_materialIndex materialIndex)
{ {
bool match = false; bool match = false;
do do
@ -210,7 +233,10 @@ public:
std::size_t matchIndex = 0; std::size_t matchIndex = 0;
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(itemTypes[i] == limitType && itemSubtypes[i] == limitSubtype && materialIndices[i] == materialIndex && exclusionTypes[i] == limitExclusion) if(itemTypes[i] == limitType
&& itemSubtypes[i] == limitSubtype
&& materialIndices[i] == materialIndex
&& exclusionTypes[i] == limitExclusion)
{ {
match = true; match = true;
matchIndex = i; matchIndex = i;
@ -220,13 +246,14 @@ public:
{ {
itemTypes.erase(itemTypes.begin() + matchIndex); itemTypes.erase(itemTypes.begin() + matchIndex);
itemSubtypes.erase(itemSubtypes.begin() + matchIndex); itemSubtypes.erase(itemSubtypes.begin() + matchIndex);
materials.erase(materials.begin() + matchIndex);
materialIndices.erase(materialIndices.begin() + matchIndex); materialIndices.erase(materialIndices.begin() + matchIndex);
materialSubindices.erase(materialSubindices.begin() + matchIndex);
exclusionTypes.erase(exclusionTypes.begin() + matchIndex); exclusionTypes.erase(exclusionTypes.begin() + matchIndex);
} }
} while(match); } while(match);
}; };
void setLimit(t_materialIndex materialIndex, unsigned int limit) // add a limit info storage item to the exclusion list, or alters an existing one // add a limit info storage item to the exclusion list, or alters an existing one
void setLimit(t_materialIndex materialIndex, unsigned int limit)
{ {
removeLimit(materialIndex); removeLimit(materialIndex);
if(limit > seedLimit) limit = seedLimit; if(limit > seedLimit) limit = seedLimit;
@ -234,7 +261,7 @@ public:
itemTypes.push_back(limitType); itemTypes.push_back(limitType);
itemSubtypes.push_back(limitSubtype); itemSubtypes.push_back(limitSubtype);
materialIndices.push_back(materialIndex); materialIndices.push_back(materialIndex);
materialSubindices.push_back((t_materialSubindex) (limit < seedLimit) ? limit : seedLimit); materials.push_back((t_material) (limit < seedLimit) ? limit : seedLimit);
exclusionTypes.push_back(limitExclusion); exclusionTypes.push_back(limitExclusion);
}; };
void clearLimits() // clears all limit info storage items from the exclusion list void clearLimits() // clears all limit info storage items from the exclusion list
@ -246,7 +273,9 @@ public:
std::size_t matchIndex; std::size_t matchIndex;
for(std::size_t i = 0; i < size(); ++i) for(std::size_t i = 0; i < size(); ++i)
{ {
if(itemTypes[i] == limitType && itemSubtypes[i] == limitSubtype && exclusionTypes[i] == limitExclusion) if(itemTypes[i] == limitType
&& itemSubtypes[i] == limitSubtype
&& exclusionTypes[i] == limitExclusion)
{ {
match = true; match = true;
matchIndex = i; matchIndex = i;
@ -257,7 +286,7 @@ public:
itemTypes.erase(itemTypes.begin() + matchIndex); itemTypes.erase(itemTypes.begin() + matchIndex);
itemSubtypes.erase(itemSubtypes.begin() + matchIndex); itemSubtypes.erase(itemSubtypes.begin() + matchIndex);
materialIndices.erase(materialIndices.begin() + matchIndex); materialIndices.erase(materialIndices.begin() + matchIndex);
materialSubindices.erase(materialSubindices.begin() + matchIndex); materials.erase( materials.begin() + matchIndex);
exclusionTypes.erase(exclusionTypes.begin() + matchIndex); exclusionTypes.erase(exclusionTypes.begin() + matchIndex);
} }
} while(match); } while(match);
@ -266,23 +295,31 @@ private:
DFHack::Core& core; DFHack::Core& core;
std::vector<t_itemType>& itemTypes; // the item types vector of the kitchen exclusion list std::vector<t_itemType>& itemTypes; // the item types vector of the kitchen exclusion list
std::vector<t_itemSubtype>& itemSubtypes; // the item subtype vector of the kitchen exclusion list std::vector<t_itemSubtype>& itemSubtypes; // the item subtype vector of the kitchen exclusion list
std::vector<t_materialSubindex>& materialSubindices; // the material subindex vector of the kitchen exclusion list std::vector<t_material>& materials; // the material subindex vector of the kitchen exclusion list
std::vector<t_materialIndex>& materialIndices; // the material index vector of the kitchen exclusion list std::vector<t_materialIndex>& materialIndices; // the material index vector of the kitchen exclusion list
std::vector<t_exclusionType>& exclusionTypes; // the exclusion type vector of the kitchen excluions list std::vector<t_exclusionType>& exclusionTypes; // the exclusion type vector of the kitchen excluions list
std::size_t size() // the size of the exclusions vectors (they are all the same size - if not, there is a problem!) std::size_t size() // the size of the exclusions vectors (they are all the same size - if not, there is a problem!)
{ {
return itemTypes.size(); return itemTypes.size();
}; };
static uint32_t start(const DFHack::Core& core) // the kludge for the exclusion position in memory //FIXME: ugly, ugly hack. Use memory.xml instead.
{ static uint32_t addr(const DFHack::Core& core, int index)
return core.p->getBase() + 0x014F0BB4 - 0x400000; {
#ifdef LINUX_BUILD
return 0x93f2b00 + 0xC * index;
#else
return core.p->getBase() + 0x014F0BB4 - 0x400000 + 0x10 * index;
#endif
}; };
}; };
DFhackCExport DFHack::command_result df_seedwatch(DFHack::Core* pCore, std::vector<std::string>& parameters) DFhackCExport DFHack::command_result df_seedwatch(DFHack::Core* pCore, std::vector<std::string>& parameters)
{ {
DFHack::Core& core = *pCore; DFHack::Core& core = *pCore;
if(!core.isValid()) return DFHack::CR_FAILURE; if(!core.isValid())
{
return DFHack::CR_FAILURE;
}
core.Suspend(); core.Suspend();
DFHack::Materials& materialsModule = *core.getMaterials(); DFHack::Materials& materialsModule = *core.getMaterials();
@ -325,12 +362,21 @@ DFhackCExport DFHack::command_result df_seedwatch(DFHack::Core* pCore, std::vect
else if(par == "info") else if(par == "info")
{ {
core.con.print("seedwatch Info:\n"); core.con.print("seedwatch Info:\n");
if(running) core.con.print("seedwatch is supervising. Use 'seedwatch stop' to stop supervision.\n"); if(running)
else core.con.print("seedwatch is not supervising. Use 'seedwatch start' to start supervision.\n"); {
core.con.print("seedwatch is supervising. Use 'seedwatch stop' to stop supervision.\n");
}
else
{
core.con.print("seedwatch is not supervising. Use 'seedwatch start' to start supervision.\n");
}
t_kitchenExclusions kitchenExclusions(core); t_kitchenExclusions kitchenExclusions(core);
std::map<t_materialIndex, unsigned int> watchMap; std::map<t_materialIndex, unsigned int> watchMap;
kitchenExclusions.fillWatchMap(watchMap); kitchenExclusions.fillWatchMap(watchMap);
if(watchMap.empty()) core.con.print("The watch list is empty.\n"); if(watchMap.empty())
{
core.con.print("The watch list is empty.\n");
}
else else
{ {
core.con.print("The watch list is:\n"); core.con.print("The watch list is:\n");
@ -339,7 +385,13 @@ DFhackCExport DFHack::command_result df_seedwatch(DFHack::Core* pCore, std::vect
core.con.print("%s : %u\n", organics[i->first].id.c_str(), i->second); core.con.print("%s : %u\n", organics[i->first].id.c_str(), i->second);
} }
} }
/*kitchenExclusions.print();*/ }
else if(par == "debug")
{
t_kitchenExclusions kitchenExclusions(core);
std::map<t_materialIndex, unsigned int> watchMap;
kitchenExclusions.fillWatchMap(watchMap);
kitchenExclusions.print();
} }
else else
{ {
@ -431,8 +483,8 @@ DFhackCExport DFHack::command_result plugin_onupdate(DFHack::Core* pCore)
{ {
DFHack::Core& core = *pCore; DFHack::Core& core = *pCore;
std::map<t_materialIndex, unsigned int> seedCount; // the number of seeds std::map<t_materialIndex, unsigned int> seedCount; // the number of seeds
std::map<t_materialIndex, t_materialSubindex> seedSubindices; // holds information needed to add entries to the cooking exclusions std::map<t_materialIndex, t_material> seedSubindices; // holds information needed to add entries to the cooking exclusions
std::map<t_materialIndex, t_materialSubindex> plantSubindices; // holds information need to add entries to the cooking exclusions std::map<t_materialIndex, t_material> plantSubindices; // holds information need to add entries to the cooking exclusions
updateCountAndSubindices(core, seedCount, seedSubindices, plantSubindices); updateCountAndSubindices(core, seedCount, seedSubindices, plantSubindices);
t_kitchenExclusions kitchenExclusions(core); t_kitchenExclusions kitchenExclusions(core);
std::map<t_materialIndex, unsigned int> watchMap; std::map<t_materialIndex, unsigned int> watchMap;