140 lines
4.2 KiB
C++
140 lines
4.2 KiB
C++
#pragma once
|
|
|
|
#include <queue>
|
|
#include <unordered_map>
|
|
|
|
#include "df/building.h"
|
|
#include "df/dfhack_material_category.h"
|
|
#include "df/item_quality.h"
|
|
#include "df/job_item.h"
|
|
|
|
#include "modules/Materials.h"
|
|
#include "modules/Persistence.h"
|
|
|
|
class ItemFilter
|
|
{
|
|
public:
|
|
ItemFilter();
|
|
|
|
void clear();
|
|
bool deserialize(std::string ser);
|
|
std::string serialize() const;
|
|
|
|
void addMaterialMask(uint32_t mask);
|
|
void clearMaterialMask();
|
|
void setMaterials(std::vector<DFHack::MaterialInfo> materials);
|
|
|
|
void incMinQuality();
|
|
void decMinQuality();
|
|
void incMaxQuality();
|
|
void decMaxQuality();
|
|
void toggleDecoratedOnly();
|
|
|
|
uint32_t getMaterialMask() const;
|
|
std::vector<std::string> getMaterials() const;
|
|
std::string getMinQuality() const;
|
|
std::string getMaxQuality() const;
|
|
bool getDecoratedOnly() const;
|
|
|
|
bool matches(df::dfhack_material_category mask) const;
|
|
bool matches(DFHack::MaterialInfo &material) const;
|
|
bool matches(df::item *item) const;
|
|
|
|
private:
|
|
// remove friend declaration when we no longer need v1 deserialization
|
|
friend void migrateV1ToV2();
|
|
|
|
df::dfhack_material_category mat_mask;
|
|
std::vector<DFHack::MaterialInfo> materials;
|
|
df::item_quality min_quality;
|
|
df::item_quality max_quality;
|
|
bool decorated_only;
|
|
|
|
bool deserializeMaterialMask(std::string ser);
|
|
bool deserializeMaterials(std::string ser);
|
|
void setMinQuality(int quality);
|
|
void setMaxQuality(int quality);
|
|
bool matchesMask(DFHack::MaterialInfo &mat) const;
|
|
};
|
|
|
|
class PlannedBuilding
|
|
{
|
|
public:
|
|
PlannedBuilding(df::building *building, const std::vector<ItemFilter> &filters);
|
|
PlannedBuilding(DFHack::PersistentDataItem &config);
|
|
|
|
bool isValid() const;
|
|
void remove();
|
|
|
|
df::building * getBuilding();
|
|
const std::vector<ItemFilter> & getFilters() const;
|
|
|
|
private:
|
|
DFHack::PersistentDataItem config;
|
|
df::building *building;
|
|
const df::building::key_field_type building_id;
|
|
const std::vector<ItemFilter> filters;
|
|
};
|
|
|
|
// building type, subtype, custom
|
|
typedef std::tuple<df::building_type, int16_t, int32_t> BuildingTypeKey;
|
|
|
|
BuildingTypeKey toBuildingTypeKey(
|
|
df::building_type btype, int16_t subtype, int32_t custom);
|
|
BuildingTypeKey toBuildingTypeKey(df::building *bld);
|
|
BuildingTypeKey toBuildingTypeKey(df::ui_build_selector *uibs);
|
|
|
|
struct BuildingTypeKeyHash
|
|
{
|
|
std::size_t operator() (const BuildingTypeKey & key) const;
|
|
};
|
|
|
|
class Planner
|
|
{
|
|
public:
|
|
class ItemFiltersWrapper
|
|
{
|
|
public:
|
|
ItemFiltersWrapper(std::vector<ItemFilter> & item_filters)
|
|
: item_filters(item_filters) { }
|
|
std::vector<ItemFilter>::reverse_iterator rbegin() const { return item_filters.rbegin(); }
|
|
std::vector<ItemFilter>::reverse_iterator rend() const { return item_filters.rend(); }
|
|
const std::vector<ItemFilter> & get() const { return item_filters; }
|
|
private:
|
|
std::vector<ItemFilter> &item_filters;
|
|
};
|
|
|
|
const std::map<std::string, bool> & getGlobalSettings() const;
|
|
bool setGlobalSetting(std::string name, bool value);
|
|
|
|
void reset();
|
|
|
|
void addPlannedBuilding(df::building *bld);
|
|
PlannedBuilding *getPlannedBuilding(df::building *bld);
|
|
|
|
bool isPlannableBuilding(BuildingTypeKey key);
|
|
|
|
// returns an empty vector if the type is not supported
|
|
ItemFiltersWrapper getItemFilters(BuildingTypeKey key);
|
|
|
|
void doCycle();
|
|
|
|
private:
|
|
std::map<std::string, bool> global_settings;
|
|
std::unordered_map<BuildingTypeKey,
|
|
std::vector<ItemFilter>,
|
|
BuildingTypeKeyHash> default_item_filters;
|
|
// building id -> PlannedBuilding
|
|
std::unordered_map<int32_t, PlannedBuilding> planned_buildings;
|
|
// vector id -> filter bucket -> queue of (building id, job_item index)
|
|
std::map<df::job_item_vector_id, std::map<std::string, std::queue<std::pair<int32_t, int>>>> tasks;
|
|
|
|
bool registerTasks(PlannedBuilding &plannedBuilding);
|
|
void unregisterBuilding(int32_t id);
|
|
void popInvalidTasks(std::queue<std::pair<int32_t, int>> &task_queue);
|
|
void doVector(df::job_item_vector_id vector_id,
|
|
std::map<std::string, std::queue<std::pair<int32_t, int>>> & buckets);
|
|
};
|
|
|
|
extern Planner planner;
|