846 lines
24 KiB
C++
846 lines
24 KiB
C++
/*
|
|
https://github.com/peterix/dfhack
|
|
Copyright (c) 2009-2011 Petr Mrázek (peterix@gmail.com)
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any
|
|
damages arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any
|
|
purpose, including commercial applications, and to alter it and
|
|
redistribute it freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must
|
|
not claim that you wrote the original software. If you use this
|
|
software in a product, an acknowledgment in the product documentation
|
|
would be appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and
|
|
must not be misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
*/
|
|
|
|
|
|
#include "Internal.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <cstring>
|
|
using namespace std;
|
|
|
|
#include "Types.h"
|
|
#include "modules/Materials.h"
|
|
#include "VersionInfo.h"
|
|
#include "MemAccess.h"
|
|
#include "Error.h"
|
|
#include "ModuleFactory.h"
|
|
#include "Core.h"
|
|
|
|
#include "MiscUtils.h"
|
|
|
|
#include "df/world.h"
|
|
#include "df/ui.h"
|
|
#include "df/item.h"
|
|
#include "df/creature_raw.h"
|
|
#include "df/caste_raw.h"
|
|
#include "df/body_part_raw.h"
|
|
#include "df/historical_figure.h"
|
|
|
|
#include "df/job_item.h"
|
|
#include "df/job_material_category.h"
|
|
#include "df/dfhack_material_category.h"
|
|
#include "df/matter_state.h"
|
|
#include "df/material_vec_ref.h"
|
|
#include "df/builtin_mats.h"
|
|
|
|
#include "df/descriptor_color.h"
|
|
#include "df/descriptor_pattern.h"
|
|
#include "df/descriptor_shape.h"
|
|
|
|
using namespace DFHack;
|
|
using namespace df::enums;
|
|
using df::global::world;
|
|
|
|
bool MaterialInfo::decode(df::item *item)
|
|
{
|
|
if (!item)
|
|
return decode(-1);
|
|
else
|
|
return decode(item->getActualMaterial(), item->getActualMaterialIndex());
|
|
}
|
|
|
|
bool MaterialInfo::decode(const df::material_vec_ref &vr, int idx)
|
|
{
|
|
if (idx < 0 || idx >= vr.mat_type.size() || idx >= vr.mat_index.size())
|
|
return decode(-1);
|
|
else
|
|
return decode(vr.mat_type[idx], vr.mat_index[idx]);
|
|
}
|
|
|
|
bool MaterialInfo::decode(int16_t type, int32_t index)
|
|
{
|
|
this->type = type;
|
|
this->index = index;
|
|
|
|
material = NULL;
|
|
mode = Builtin; subtype = 0;
|
|
inorganic = NULL; plant = NULL; creature = NULL;
|
|
figure = NULL;
|
|
|
|
df::world_raws &raws = df::global::world->raws;
|
|
|
|
if (type < 0 || type >= sizeof(raws.mat_table.builtin)/sizeof(void*))
|
|
return false;
|
|
|
|
if (index < 0)
|
|
{
|
|
material = raws.mat_table.builtin[type];
|
|
}
|
|
else if (type == 0)
|
|
{
|
|
mode = Inorganic;
|
|
inorganic = df::inorganic_raw::find(index);
|
|
if (!inorganic)
|
|
return false;
|
|
material = &inorganic->material;
|
|
}
|
|
else if (type < CREATURE_BASE)
|
|
{
|
|
material = raws.mat_table.builtin[type];
|
|
}
|
|
else if (type < FIGURE_BASE)
|
|
{
|
|
mode = Creature;
|
|
subtype = type-CREATURE_BASE;
|
|
creature = df::creature_raw::find(index);
|
|
if (!creature || subtype >= creature->material.size())
|
|
return false;
|
|
material = creature->material[subtype];
|
|
}
|
|
else if (type < PLANT_BASE)
|
|
{
|
|
mode = Creature;
|
|
subtype = type-FIGURE_BASE;
|
|
figure = df::historical_figure::find(index);
|
|
if (!figure)
|
|
return false;
|
|
creature = df::creature_raw::find(figure->race);
|
|
if (!creature || subtype >= creature->material.size())
|
|
return false;
|
|
material = creature->material[subtype];
|
|
}
|
|
else if (type < END_BASE)
|
|
{
|
|
mode = Plant;
|
|
subtype = type-PLANT_BASE;
|
|
plant = df::plant_raw::find(index);
|
|
if (!plant || subtype >= plant->material.size())
|
|
return false;
|
|
material = plant->material[subtype];
|
|
}
|
|
else
|
|
{
|
|
material = raws.mat_table.builtin[type];
|
|
}
|
|
|
|
return (material != NULL);
|
|
}
|
|
|
|
bool MaterialInfo::find(const std::string &token)
|
|
{
|
|
std::vector<std::string> items;
|
|
split_string(&items, token, ":");
|
|
|
|
if (items[0] == "INORGANIC")
|
|
return findInorganic(vector_get(items,1));
|
|
if (items[0] == "CREATURE_MAT" || items[0] == "CREATURE")
|
|
return findCreature(vector_get(items,1), vector_get(items,2));
|
|
if (items[0] == "PLANT_MAT" || items[0] == "PLANT")
|
|
return findPlant(vector_get(items,1), vector_get(items,2));
|
|
|
|
if (items.size() == 1)
|
|
{
|
|
if (findBuiltin(items[0]))
|
|
return true;
|
|
if (findInorganic(items[0]))
|
|
return true;
|
|
if (findPlant(items[0], ""))
|
|
return true;
|
|
}
|
|
else if (items.size() == 2)
|
|
{
|
|
if (findPlant(items[0], items[1]))
|
|
return true;
|
|
if (findCreature(items[0], items[1]))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MaterialInfo::findBuiltin(const std::string &token)
|
|
{
|
|
if (token.empty())
|
|
return decode(-1);
|
|
|
|
if (token == "NONE") {
|
|
decode(-1);
|
|
return true;
|
|
}
|
|
|
|
df::world_raws &raws = df::global::world->raws;
|
|
for (int i = 1; i < NUM_BUILTIN; i++)
|
|
if (raws.mat_table.builtin[i]->id == token)
|
|
return decode(i, -1);
|
|
return decode(-1);
|
|
}
|
|
|
|
bool MaterialInfo::findInorganic(const std::string &token)
|
|
{
|
|
if (token.empty())
|
|
return decode(-1);
|
|
|
|
if (token == "NONE") {
|
|
decode(0, -1);
|
|
return true;
|
|
}
|
|
|
|
df::world_raws &raws = df::global::world->raws;
|
|
for (unsigned i = 0; i < raws.inorganics.size(); i++)
|
|
{
|
|
df::inorganic_raw *p = raws.inorganics[i];
|
|
if (p->id == token)
|
|
return decode(0, i);
|
|
}
|
|
return decode(-1);
|
|
}
|
|
|
|
bool MaterialInfo::findPlant(const std::string &token, const std::string &subtoken)
|
|
{
|
|
if (token.empty())
|
|
return decode(-1);
|
|
df::world_raws &raws = df::global::world->raws;
|
|
for (unsigned i = 0; i < raws.plants.all.size(); i++)
|
|
{
|
|
df::plant_raw *p = raws.plants.all[i];
|
|
if (p->id != token)
|
|
continue;
|
|
|
|
// As a special exception, return the structural material with empty subtoken
|
|
if (subtoken.empty())
|
|
return decode(p->material_defs.type_basic_mat, p->material_defs.idx_basic_mat);
|
|
|
|
for (unsigned j = 0; j < p->material.size(); j++)
|
|
if (p->material[j]->id == subtoken)
|
|
return decode(PLANT_BASE+j, i);
|
|
|
|
break;
|
|
}
|
|
return decode(-1);
|
|
}
|
|
|
|
bool MaterialInfo::findCreature(const std::string &token, const std::string &subtoken)
|
|
{
|
|
if (token.empty() || subtoken.empty())
|
|
return decode(-1);
|
|
df::world_raws &raws = df::global::world->raws;
|
|
for (unsigned i = 0; i < raws.creatures.all.size(); i++)
|
|
{
|
|
df::creature_raw *p = raws.creatures.all[i];
|
|
if (p->creature_id != token)
|
|
continue;
|
|
|
|
for (unsigned j = 0; j < p->material.size(); j++)
|
|
if (p->material[j]->id == subtoken)
|
|
return decode(CREATURE_BASE+j, i);
|
|
|
|
break;
|
|
}
|
|
return decode(-1);
|
|
}
|
|
|
|
std::string MaterialInfo::toString(uint16_t temp, bool named)
|
|
{
|
|
if (type == -1)
|
|
return "NONE";
|
|
if (!material)
|
|
return stl_sprintf("INVALID %d:%d", type, index);
|
|
|
|
df::matter_state state = matter_state::Solid;
|
|
if (temp >= material->heat.melting_point)
|
|
state = matter_state::Liquid;
|
|
if (temp >= material->heat.boiling_point)
|
|
state = matter_state::Gas;
|
|
|
|
std::string name = material->state_name[state];
|
|
if (!material->prefix.empty())
|
|
name = material->prefix + " " + name;
|
|
|
|
if (named && figure)
|
|
name += stl_sprintf(" of HF %d", index);
|
|
return name;
|
|
}
|
|
|
|
df::craft_material_class MaterialInfo::getCraftClass()
|
|
{
|
|
if (!material)
|
|
return craft_material_class::None;
|
|
|
|
if (type == 0 && index == -1)
|
|
return craft_material_class::Stone;
|
|
|
|
FOR_ENUM_ITEMS(material_flags, i)
|
|
{
|
|
df::craft_material_class ccv = ENUM_ATTR(material_flags, type, i);
|
|
if (ccv == craft_material_class::None)
|
|
continue;
|
|
if (material->flags.is_set(i))
|
|
return ccv;
|
|
}
|
|
|
|
return craft_material_class::None;
|
|
}
|
|
|
|
bool MaterialInfo::isAnyCloth()
|
|
{
|
|
using namespace df::enums::material_flags;
|
|
|
|
return material && (
|
|
material->flags.is_set(THREAD_PLANT) ||
|
|
material->flags.is_set(SILK) ||
|
|
material->flags.is_set(YARN)
|
|
);
|
|
}
|
|
|
|
bool MaterialInfo::matches(const df::job_material_category &cat)
|
|
{
|
|
if (!material)
|
|
return false;
|
|
|
|
#define TEST(bit,flag) if (cat.bits.bit && material->flags.is_set(flag)) return true;
|
|
|
|
using namespace df::enums::material_flags;
|
|
TEST(plant, STRUCTURAL_PLANT_MAT);
|
|
TEST(wood, WOOD);
|
|
TEST(cloth, THREAD_PLANT);
|
|
TEST(silk, SILK);
|
|
TEST(leather, LEATHER);
|
|
TEST(bone, BONE);
|
|
TEST(shell, SHELL);
|
|
TEST(wood2, WOOD);
|
|
TEST(soap, SOAP);
|
|
TEST(tooth, TOOTH);
|
|
TEST(horn, HORN);
|
|
TEST(pearl, PEARL);
|
|
TEST(yarn, YARN);
|
|
return false;
|
|
}
|
|
|
|
bool MaterialInfo::matches(const df::dfhack_material_category &cat)
|
|
{
|
|
if (!material)
|
|
return false;
|
|
|
|
df::job_material_category mc;
|
|
mc.whole = cat.whole;
|
|
if (matches(mc))
|
|
return true;
|
|
|
|
using namespace df::enums::material_flags;
|
|
using namespace df::enums::inorganic_flags;
|
|
TEST(metal, IS_METAL);
|
|
TEST(stone, IS_STONE);
|
|
if (cat.bits.stone && type == 0 && index == -1)
|
|
return true;
|
|
if (cat.bits.sand && inorganic && inorganic->flags.is_set(SOIL_SAND))
|
|
return true;
|
|
TEST(glass, IS_GLASS);
|
|
if (cat.bits.clay && linear_index(material->reaction_product.id, std::string("FIRED_MAT")) >= 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
#undef TEST
|
|
|
|
bool MaterialInfo::matches(const df::job_item &item)
|
|
{
|
|
if (!isValid()) return false;
|
|
|
|
df::job_item_flags1 ok1, mask1;
|
|
getMatchBits(ok1, mask1);
|
|
|
|
df::job_item_flags2 ok2, mask2;
|
|
getMatchBits(ok2, mask2);
|
|
|
|
df::job_item_flags3 ok3, mask3;
|
|
getMatchBits(ok3, mask3);
|
|
|
|
return bits_match(item.flags1.whole, ok1.whole, mask1.whole) &&
|
|
bits_match(item.flags2.whole, ok2.whole, mask2.whole) &&
|
|
bits_match(item.flags3.whole, ok3.whole, mask3.whole);
|
|
}
|
|
|
|
void MaterialInfo::getMatchBits(df::job_item_flags1 &ok, df::job_item_flags1 &mask)
|
|
{
|
|
ok.whole = mask.whole = 0;
|
|
if (!isValid()) return;
|
|
|
|
#define MAT_FLAG(name) material->flags.is_set(df::enums::material_flags::name)
|
|
#define FLAG(field, name) (field && field->flags.is_set(name))
|
|
#define TEST(bit, check) \
|
|
mask.bits.bit = true; ok.bits.bit = !!(check);
|
|
|
|
bool structural = MAT_FLAG(STRUCTURAL_PLANT_MAT);
|
|
|
|
TEST(millable, structural && FLAG(plant, plant_raw_flags::MILL));
|
|
TEST(sharpenable, MAT_FLAG(IS_STONE));
|
|
TEST(distillable, structural && FLAG(plant, plant_raw_flags::DRINK));
|
|
TEST(processable, structural && FLAG(plant, plant_raw_flags::THREAD));
|
|
TEST(bag, isAnyCloth() || MAT_FLAG(LEATHER));
|
|
TEST(cookable, MAT_FLAG(EDIBLE_COOKED));
|
|
TEST(extract_bearing_plant, structural && FLAG(plant, plant_raw_flags::EXTRACT_STILL_VIAL));
|
|
TEST(extract_bearing_fish, false);
|
|
TEST(extract_bearing_vermin, false);
|
|
TEST(processable_to_vial, structural && FLAG(plant, plant_raw_flags::EXTRACT_VIAL));
|
|
TEST(processable_to_bag, structural && FLAG(plant, plant_raw_flags::LEAVES));
|
|
TEST(processable_to_barrel, structural && FLAG(plant, plant_raw_flags::EXTRACT_BARREL));
|
|
TEST(solid, !(MAT_FLAG(ALCOHOL_PLANT) ||
|
|
MAT_FLAG(ALCOHOL_CREATURE) ||
|
|
MAT_FLAG(LIQUID_MISC_PLANT) ||
|
|
MAT_FLAG(LIQUID_MISC_CREATURE) ||
|
|
MAT_FLAG(LIQUID_MISC_OTHER)));
|
|
TEST(tameable_vermin, false);
|
|
TEST(sharpenable, MAT_FLAG(IS_STONE));
|
|
TEST(milk, linear_index(material->reaction_product.id, std::string("CHEESE_MAT")) >= 0);
|
|
//04000000 - "milkable" - vtable[107],1,1
|
|
}
|
|
|
|
void MaterialInfo::getMatchBits(df::job_item_flags2 &ok, df::job_item_flags2 &mask)
|
|
{
|
|
ok.whole = mask.whole = 0;
|
|
if (!isValid()) return;
|
|
|
|
bool is_cloth = isAnyCloth();
|
|
|
|
TEST(dye, MAT_FLAG(IS_DYE));
|
|
TEST(dyeable, is_cloth);
|
|
TEST(dyed, is_cloth);
|
|
TEST(sewn_imageless, is_cloth);
|
|
TEST(glass_making, MAT_FLAG(CRYSTAL_GLASSABLE));
|
|
|
|
TEST(fire_safe, material->heat.melting_point > 11000);
|
|
TEST(magma_safe, material->heat.melting_point > 12000);
|
|
TEST(deep_material, FLAG(inorganic, df::enums::inorganic_flags::DEEP_ANY));
|
|
TEST(non_economic, inorganic && !(df::global::ui && df::global::ui->economic_stone[index]));
|
|
|
|
TEST(plant, plant);
|
|
TEST(silk, MAT_FLAG(SILK));
|
|
TEST(leather, MAT_FLAG(LEATHER));
|
|
TEST(bone, MAT_FLAG(BONE));
|
|
TEST(shell, MAT_FLAG(SHELL));
|
|
TEST(totemable, false);
|
|
TEST(horn, MAT_FLAG(HORN));
|
|
TEST(pearl, MAT_FLAG(PEARL));
|
|
TEST(soap, MAT_FLAG(SOAP));
|
|
TEST(ivory_tooth, MAT_FLAG(TOOTH));
|
|
//TEST(hair_wool, MAT_FLAG(YARN));
|
|
TEST(yarn, MAT_FLAG(YARN));
|
|
}
|
|
|
|
void MaterialInfo::getMatchBits(df::job_item_flags3 &ok, df::job_item_flags3 &mask)
|
|
{
|
|
ok.whole = mask.whole = 0;
|
|
if (!isValid()) return;
|
|
|
|
TEST(hard, MAT_FLAG(ITEMS_HARD));
|
|
}
|
|
|
|
#undef MAT_FLAG
|
|
#undef FLAG
|
|
#undef TEST
|
|
|
|
bool DFHack::parseJobMaterialCategory(df::job_material_category *cat, const std::string &token)
|
|
{
|
|
cat->whole = 0;
|
|
|
|
std::vector<std::string> items;
|
|
split_string(&items, toLower(token), ",", true);
|
|
|
|
for (unsigned i = 0; i < items.size(); i++)
|
|
{
|
|
int id = findBitfieldField(*cat, items[i]);
|
|
if (id < 0)
|
|
return false;
|
|
|
|
cat->whole |= (1 << id);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DFHack::parseJobMaterialCategory(df::dfhack_material_category *cat, const std::string &token)
|
|
{
|
|
cat->whole = 0;
|
|
|
|
std::vector<std::string> items;
|
|
split_string(&items, toLower(token), ",", true);
|
|
|
|
for (unsigned i = 0; i < items.size(); i++)
|
|
{
|
|
int id = findBitfieldField(*cat, items[i]);
|
|
if (id < 0)
|
|
return false;
|
|
|
|
cat->whole |= (1 << id);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Module* DFHack::createMaterials()
|
|
{
|
|
return new Materials();
|
|
}
|
|
|
|
class Materials::Private
|
|
{
|
|
public:
|
|
Process * owner;
|
|
OffsetGroup * OG_Materials;
|
|
void * vector_races;
|
|
void * vector_other;
|
|
};
|
|
|
|
Materials::Materials()
|
|
{
|
|
Core & c = Core::getInstance();
|
|
d = new Private;
|
|
d->owner = c.p;
|
|
OffsetGroup *OG_Materials = d->OG_Materials = c.vinfo->getGroup("Materials");
|
|
{
|
|
d->vector_races = OG_Materials->getAddress("creature_type_vector");
|
|
}
|
|
}
|
|
|
|
Materials::~Materials()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
bool Materials::Finish()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
t_matgloss::t_matgloss()
|
|
{
|
|
fore = 0;
|
|
back = 0;
|
|
bright = 0;
|
|
|
|
value = 0;
|
|
wall_tile = 0;
|
|
boulder_tile = 0;
|
|
}
|
|
|
|
bool t_matglossInorganic::isOre()
|
|
{
|
|
if (!ore_chances.empty())
|
|
return true;
|
|
if (!strand_chances.empty())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool t_matglossInorganic::isGem()
|
|
{
|
|
return is_gem;
|
|
}
|
|
|
|
bool Materials::CopyInorganicMaterials (std::vector<t_matglossInorganic> & inorganic)
|
|
{
|
|
Process * p = d->owner;
|
|
uint32_t size = world->raws.inorganics.size();
|
|
inorganic.clear();
|
|
inorganic.reserve (size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
df::inorganic_raw *orig = world->raws.inorganics[i];
|
|
t_matglossInorganic mat;
|
|
mat.id = orig->id;
|
|
mat.name = orig->material.stone_name;
|
|
|
|
mat.ore_types = orig->metal_ore.mat_index;
|
|
mat.ore_chances = orig->metal_ore.probability;
|
|
mat.strand_types = orig->thread_metal.mat_index;
|
|
mat.strand_chances = orig->thread_metal.probability;
|
|
mat.value = orig->material.material_value;
|
|
mat.wall_tile = orig->material.tile;
|
|
mat.boulder_tile = orig->material.item_symbol;
|
|
mat.fore = orig->material.basic_color[0];
|
|
mat.bright = orig->material.basic_color[1];
|
|
mat.is_gem = orig->material.flags.is_set(material_flags::IS_GEM);
|
|
inorganic.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::CopyOrganicMaterials (std::vector<t_matgloss> & organic)
|
|
{
|
|
uint32_t size = world->raws.plants.all.size();
|
|
organic.clear();
|
|
organic.reserve (size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matgloss mat;
|
|
mat.id = world->raws.plants.all[i]->id;
|
|
organic.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::CopyWoodMaterials (std::vector<t_matgloss> & tree)
|
|
{
|
|
uint32_t size = world->raws.plants.trees.size();
|
|
tree.clear();
|
|
tree.reserve (size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matgloss mat;
|
|
mat.id = world->raws.plants.trees[i]->id;
|
|
tree.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::CopyPlantMaterials (std::vector<t_matgloss> & plant)
|
|
{
|
|
uint32_t size = world->raws.plants.bushes.size();
|
|
plant.clear();
|
|
plant.reserve (size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matgloss mat;
|
|
mat.id = world->raws.plants.bushes[i]->id;
|
|
plant.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::ReadCreatureTypes (void)
|
|
{
|
|
uint32_t size = world->raws.creatures.all.size();
|
|
race.clear();
|
|
race.reserve (size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matgloss mat;
|
|
mat.id = world->raws.creatures.all[i]->creature_id;
|
|
race.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::ReadOthers(void)
|
|
{
|
|
uint32_t size = df::enums::builtin_mats::_last_item_of_builtin_mats + 1;
|
|
other.clear();
|
|
other.reserve(size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matglossOther mat;
|
|
mat.id = world->raws.mat_table.builtin[i]->id;
|
|
other.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::ReadDescriptorColors (void)
|
|
{
|
|
uint32_t size = world->raws.language.colors.size();
|
|
|
|
color.clear();
|
|
if(size == 0)
|
|
return false;
|
|
color.reserve(size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
df::descriptor_color *c = world->raws.language.colors[i];
|
|
t_descriptor_color col;
|
|
col.id = c->id;
|
|
col.name = c->name;
|
|
col.red = c->red;
|
|
col.green = c->green;
|
|
col.blue = c->blue;
|
|
color.push_back(col);
|
|
}
|
|
|
|
size = world->raws.language.patterns.size();
|
|
alldesc.clear();
|
|
alldesc.reserve(size);
|
|
for (uint32_t i = 0; i < size;i++)
|
|
{
|
|
t_matgloss mat;
|
|
mat.id = world->raws.language.patterns[i]->id;
|
|
alldesc.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::ReadCreatureTypesEx (void)
|
|
{
|
|
uint32_t size = world->raws.creatures.all.size();
|
|
raceEx.clear();
|
|
raceEx.reserve (size);
|
|
for (uint32_t i = 0; i < size; i++)
|
|
{
|
|
df::creature_raw *cr = world->raws.creatures.all[i];
|
|
t_creaturetype mat;
|
|
mat.id = cr->creature_id;
|
|
mat.tile_character = cr->creature_tile;
|
|
mat.tilecolor.fore = cr->color[0];
|
|
mat.tilecolor.back = cr->color[1];
|
|
mat.tilecolor.bright = cr->color[2];
|
|
|
|
uint32_t sizecas = cr->caste.size();
|
|
for (uint32_t j = 0; j < sizecas;j++)
|
|
{
|
|
df::caste_raw *ca = cr->caste[j];
|
|
/* caste name */
|
|
t_creaturecaste caste;
|
|
caste.id = ca->caste_id;
|
|
caste.singular = ca->caste_name[0];
|
|
caste.plural = ca->caste_name[1];
|
|
caste.adjective = ca->caste_name[2];
|
|
/*
|
|
// color mod reading
|
|
// Caste + offset > color mod vector
|
|
vector <char *> & p_colormod = *(vector<char*> *) (world->raws.creatures.all[i]->caste + caste_colormod_offset);
|
|
uint32_t sizecolormod = p_colormod.size();
|
|
caste.ColorModifier.resize(sizecolormod);
|
|
for(uint32_t k = 0; k < sizecolormod;k++)
|
|
{
|
|
// color mod [0] -> color list
|
|
vector <uint32_t> & p_colorlist = *(vector<uint32_t> *) (p_colormod[k]);
|
|
uint32_t sizecolorlist = p_colorlist.size();
|
|
caste.ColorModifier[k].colorlist.resize(sizecolorlist);
|
|
for(uint32_t l = 0; l < sizecolorlist; l++)
|
|
caste.ColorModifier[k].colorlist[l] = p_colorlist[l];
|
|
// color mod [color_modifier_part_offset] = string part
|
|
caste.ColorModifier[k].part = p->readSTLString( p_colormod[k] + color_modifier_part_offset);
|
|
caste.ColorModifier[k].startdate = p->readDWord( p_colormod[k] + color_modifier_startdate_offset );
|
|
caste.ColorModifier[k].enddate = p->readDWord( p_colormod[k] + color_modifier_enddate_offset );
|
|
}
|
|
*/
|
|
// body parts
|
|
caste.bodypart.empty();
|
|
uint32_t sizebp = ca->body_parts.size();
|
|
for (uint32_t k = 0; k < sizebp; k++)
|
|
{
|
|
df::body_part_raw *bp = ca->body_parts[k];
|
|
t_bodypart part;
|
|
part.id = bp->part_code;
|
|
part.category = bp->part_name;
|
|
caste.bodypart.push_back(part);
|
|
}
|
|
|
|
t_attrib *phys[] = {
|
|
&caste.strength,
|
|
&caste.agility,
|
|
&caste.toughness,
|
|
&caste.endurance,
|
|
&caste.recuperation,
|
|
&caste.disease_resistance
|
|
};
|
|
for (uint32_t k = 0; k < 6; k++)
|
|
{
|
|
phys[k]->level = ca->attributes.phys_att_range[k][0];
|
|
phys[k]->field_4 = ca->attributes.phys_att_range[k][1];
|
|
phys[k]->field_8 = ca->attributes.phys_att_range[k][2];
|
|
phys[k]->field_C = ca->attributes.phys_att_range[k][3];
|
|
phys[k]->leveldiff = ca->attributes.phys_att_range[k][4];
|
|
phys[k]->field_14 = ca->attributes.phys_att_range[k][5];
|
|
phys[k]->field_18 = ca->attributes.phys_att_range[k][6];
|
|
}
|
|
t_attrib *ment[] = {
|
|
&caste.analytical_ability,
|
|
&caste.focus,
|
|
&caste.willpower,
|
|
&caste.creativity,
|
|
&caste.intuition,
|
|
&caste.patience,
|
|
&caste.memory,
|
|
&caste.linguistic_ability,
|
|
&caste.spatial_sense,
|
|
&caste.musicality,
|
|
&caste.kinesthetic_sense,
|
|
&caste.empathy,
|
|
&caste.social_awareness
|
|
};
|
|
for (uint32_t k = 0; k < 13; k++)
|
|
{
|
|
ment[k]->level = ca->attributes.ment_att_range[k][0];
|
|
ment[k]->field_4 = ca->attributes.ment_att_range[k][1];
|
|
ment[k]->field_8 = ca->attributes.ment_att_range[k][2];
|
|
ment[k]->field_C = ca->attributes.ment_att_range[k][3];
|
|
ment[k]->leveldiff = ca->attributes.ment_att_range[k][4];
|
|
ment[k]->field_14 = ca->attributes.ment_att_range[k][5];
|
|
ment[k]->field_18 = ca->attributes.ment_att_range[k][6];
|
|
}
|
|
mat.castes.push_back(caste);
|
|
}
|
|
for (uint32_t j = 0; j < world->raws.creatures.all[i]->material.size(); j++)
|
|
{
|
|
t_creatureextract extract;
|
|
extract.id = world->raws.creatures.all[i]->material[j]->id;
|
|
mat.extract.push_back(extract);
|
|
}
|
|
raceEx.push_back(mat);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Materials::ReadAllMaterials(void)
|
|
{
|
|
bool ok = true;
|
|
ok &= this->ReadCreatureTypes();
|
|
ok &= this->ReadCreatureTypesEx();
|
|
ok &= this->ReadDescriptorColors();
|
|
ok &= this->ReadOthers();
|
|
return ok;
|
|
}
|
|
|
|
std::string Materials::getDescription(const t_material & mat)
|
|
{
|
|
MaterialInfo mi(mat.material, mat.index);
|
|
if (mi.creature)
|
|
return mi.creature->creature_id + " " + mi.material->id;
|
|
else if (mi.plant)
|
|
return mi.plant->id + " " + mi.material->id;
|
|
else
|
|
return mi.material->id;
|
|
}
|
|
|
|
// type of material only so we know which vector to retrieve
|
|
// This is completely worthless now
|
|
std::string Materials::getType(const t_material & mat)
|
|
{
|
|
MaterialInfo mi(mat.material, mat.index);
|
|
switch (mi.mode)
|
|
{
|
|
case MaterialInfo::Builtin:
|
|
return "builtin";
|
|
case MaterialInfo::Inorganic:
|
|
return "inorganic";
|
|
case MaterialInfo::Creature:
|
|
return "creature";
|
|
case MaterialInfo::Plant:
|
|
return "plant";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|