{

if (!Units::isCitizen(unit))

return false;

if (!unit->status2.limbs_grasp_count)

return false;

if (unit->mood != mood_type::None)

return false;

if (!ENUM_ATTR(profession,moodable,unit->profession))

return false;

if (!Units::casteFlagSet(unit->race, unit->caste, caste_raw_flags::STRANGE_MOODS))

return false;

return true;

{

if (!unit->status.current_soul)

return job_skill::STONECRAFT;

df::historical_entity *civ = df::historical_entity::find(unit->civ_id);

df::unit_soul *soul = unit->status.current_soul;

vector<df::job_skill> skills;

df::skill_rating level = skill_rating::Dabbling;

for (size_t i = 0; i < soul->skills.size(); i++)

{

df::unit_skill *skill = soul->skills[i];

switch (skill->id)

{

case job_skill::MINING:

case job_skill::CARPENTRY:

case job_skill::ENGRAVE_STONE:

case job_skill::MASONRY:

case job_skill::TANNER:

case job_skill::WEAVING:

case job_skill::CLOTHESMAKING:

case job_skill::FORGE_WEAPON:

case job_skill::FORGE_ARMOR:

case job_skill::FORGE_FURNITURE:

case job_skill::CUTGEM:

case job_skill::ENCRUSTGEM:

case job_skill::WOODCRAFT:

case job_skill::STONECRAFT:

case job_skill::METALCRAFT:

case job_skill::GLASSMAKER:

case job_skill::LEATHERWORK:

case job_skill::BONECARVE:

case job_skill::BOWYER:

case job_skill::MECHANICS:

case job_skill::CUT_STONE:

case job_skill::CARVE_STONE:

if (skill->rating > level)

{

skills.clear();

level = skill->rating;

}

if (skill->rating == level)

skills.push_back(skill->id);

break;

default:

break;

}

}

if (!skills.size() && civ)

{

if (civ->resources.permitted_skill[job_skill::WOODCRAFT])

skills.push_back(job_skill::WOODCRAFT);

if (civ->resources.permitted_skill[job_skill::STONECRAFT])

skills.push_back(job_skill::STONECRAFT);

if (civ->resources.permitted_skill[job_skill::BONECARVE])

skills.push_back(job_skill::BONECARVE);

}

if (!skills.size())

skills.push_back(job_skill::STONECRAFT);

return skills[rng.df_trandom(skills.size())];

{

for (size_t i = 0; i < created_item_type->size(); i++)

{

if (created_item_type->at(i) == item_type::BAR &&

created_item_subtype->at(i) == -1 &&

created_item_mattype->at(i) == 0 &&

created_item_matindex->at(i) == idx)

return created_item_count->at(i);

}

return 0;

{

if (!Core::getInstance().isMapLoaded() || !World::isFortressMode()) {

out.printerr("Cannot enable {} without a loaded fort.\n", plugin_name);

return CR_FAILURE;

}

bool force = false;

df::unit *unit = NULL;

df::mood_type type = mood_type::None;

df::job_skill skill = job_skill::NONE;

for (size_t i = 0; i < parameters.size(); i++)

{

if(parameters[i] == "help" || parameters[i] == "?")

return CR_WRONG_USAGE;

else if(parameters[i] == "--force")

force = true;

else if(parameters[i] == "--id")

{

i++;

if (i == parameters.size())

{

out.printerr("No unit id specified!\n");

return CR_WRONG_USAGE;

}

unit = df::unit::find(std::stoi(parameters[i]));

if (!unit)

return CR_FAILURE;

}

else if(parameters[i] == "--unit")

{

unit = DFHack::Gui::getSelectedUnit(out);

if (!unit)

return CR_FAILURE;

}

else if (parameters[i] == "--type")

{

i++;

if (i == parameters.size())

{

out.printerr("No mood type specified!\n");

return CR_WRONG_USAGE;

}

if (parameters[i] == "fey")

type = mood_type::Fey;

else if (parameters[i] == "secretive")

type = mood_type::Secretive;

else if (parameters[i] == "possessed")

type = mood_type::Possessed;

else if (parameters[i] == "fell")

type = mood_type::Fell;

else if (parameters[i] == "macabre")

type = mood_type::Macabre;

else

{

out.printerr("Mood type '{}' not recognized!\n", parameters[i]);

return CR_WRONG_USAGE;

}

}

else if (parameters[i] == "--skill")

{

i++;

if (i == parameters.size())

{

out.printerr("No mood skill specified!\n");

return CR_WRONG_USAGE;

}

else if (parameters[i] == "miner")

skill = job_skill::MINING;

else if (parameters[i] == "carpenter")

skill = job_skill::CARPENTRY;

else if (parameters[i] == "engraver")

skill = job_skill::ENGRAVE_STONE;

else if (parameters[i] == "mason")

skill = job_skill::MASONRY;

else if (parameters[i] == "stonecutter")

skill = job_skill::CUT_STONE;

else if (parameters[i] == "stonecarver")

skill = job_skill::CARVE_STONE;

else if (parameters[i] == "tanner")

skill = job_skill::TANNER;

else if (parameters[i] == "weaver")

skill = job_skill::WEAVING;

else if (parameters[i] == "clothier")

skill = job_skill::CLOTHESMAKING;

else if (parameters[i] == "weaponsmith")

skill = job_skill::FORGE_WEAPON;

else if (parameters[i] == "armorsmith")

skill = job_skill::FORGE_ARMOR;

else if (parameters[i] == "metalsmith")

skill = job_skill::FORGE_FURNITURE;

else if (parameters[i] == "gemcutter")

skill = job_skill::CUTGEM;

else if (parameters[i] == "gemsetter")

skill = job_skill::ENCRUSTGEM;

else if (parameters[i] == "woodcrafter")

skill = job_skill::WOODCRAFT;

else if (parameters[i] == "stonecrafter")

skill = job_skill::STONECRAFT;

else if (parameters[i] == "metalcrafter")

skill = job_skill::METALCRAFT;

else if (parameters[i] == "glassmaker")

skill = job_skill::GLASSMAKER;

else if (parameters[i] == "leatherworker")

skill = job_skill::LEATHERWORK;

else if (parameters[i] == "bonecarver")

skill = job_skill::BONECARVE;

else if (parameters[i] == "bowyer")

skill = job_skill::BOWYER;

else if (parameters[i] == "mechanic")

skill = job_skill::MECHANICS;

else

{

out.printerr("Mood skill '{}' not recognized!\n", parameters[i]);

return CR_WRONG_USAGE;

}

}

else

{

out.printerr("Unrecognized parameter: {}\n", parameters[i]);

return CR_WRONG_USAGE;

}

}

// First, check if moods are enabled at all

if (!d_init->feature.flags.is_set(d_init_flags4::ARTIFACTS))

{

out.printerr("ARTIFACTS are not enabled!\n");

return CR_FAILURE;

}

if (debug_nomoods && *debug_nomoods)

{

out.printerr("Strange moods disabled via debug flag!\n");

return CR_FAILURE;

}

if (plotinfo->mood_cooldown && !force)

{

out.printerr("Last strange mood happened too recently!\n");

return CR_FAILURE;

}

// Also, make sure there isn't a mood already running

vector<df::unit *> citizens;

Units::getCitizens(citizens, true);

for (auto cur : citizens)

{

if (cur->flags1.bits.has_mood)

{

plotinfo->mood_cooldown = 1000;

out.printerr("A strange mood is already in progress!\n");

return CR_FAILURE;

}

}

// See which units are eligible to enter moods

vector<df::unit *> moodable_units;

bool mood_available = false;

for (auto cur : citizens)

{

if (!isUnitMoodable(cur))

continue;

if (!cur->flags1.bits.had_mood)

mood_available = true;

moodable_units.push_back(cur);

}

if (!mood_available)

{

out.printerr("No dwarves are available to enter a mood!\n");

return CR_FAILURE;

}

// If unit was manually selected, redo checks explicitly

if (unit)

{

if (!isUnitMoodable(unit))

{

out.printerr("Selected unit is not eligible to enter a strange mood!\n");

return CR_FAILURE;

}

if (unit->flags1.bits.had_mood)

{

out.printerr("Selected unit has already had a strange mood!\n");

return CR_FAILURE;

}

}

// Obey in-game mood limits

if (!force)

{

if (moodable_units.size() < 20)

{

out.printerr("Fortress is not eligible for a strange mood at this time - not enough moodable units.\n");

return CR_FAILURE;

}

int num_items = 0;

for (size_t i = 0; i < created_item_count->size(); i++)

num_items += created_item_count->at(i);

int num_revealed_tiles = 0;

for (size_t i = 0; i < world->map.map_blocks.size(); i++)

{

df::map_block *blk = world->map.map_blocks[i];

for (int x = 0; x < 16; x++)

for (int y = 0; y < 16; y++)

if (blk->designation[x][y].bits.subterranean && !blk->designation[x][y].bits.hidden)

num_revealed_tiles++;

}

if (num_revealed_tiles / 2304 < plotinfo->tasks.num_artifacts)

{

out.printerr("Fortress is not eligible for a strange mood at this time - not enough subterranean tiles revealed.\n");

return CR_FAILURE;

}

if (num_items / 200 < plotinfo->tasks.num_artifacts)

{

out.printerr("Fortress is not eligible for a strange mood at this time - not enough items created\n");

return CR_FAILURE;

}

}

// Randomly select a unit to enter a mood

if (!unit)

{

vector<int32_t> tickets;

for (size_t i = 0; i < moodable_units.size(); i++)

{

df::unit *cur = moodable_units[i];

if (cur->flags1.bits.had_mood)

continue;

if (cur->relationship_ids[df::unit_relationship_type::Dragger] != -1)

continue;

if (cur->relationship_ids[df::unit_relationship_type::Draggee] != -1)

continue;

tickets.push_back(i);

for (int j = 0; j < 5; j++)

tickets.push_back(i);

switch (cur->profession)

{

case profession::WOODWORKER:

case profession::CARPENTER:

case profession::BOWYER:

case profession::STONEWORKER:

case profession::STONE_CARVER:

for (int j = 0; j < 5; j++)

tickets.push_back(i);

break;

case profession::METALSMITH:

case profession::WEAPONSMITH:

case profession::ARMORER:

case profession::BLACKSMITH:

case profession::METALCRAFTER:

case profession::JEWELER:

case profession::GEM_CUTTER:

case profession::GEM_SETTER:

case profession::CRAFTSMAN:

case profession::WOODCRAFTER:

case profession::STONECRAFTER:

case profession::LEATHERWORKER:

case profession::BONE_CARVER:

case profession::WEAVER:

case profession::CLOTHIER:

case profession::GLASSMAKER:

for (int j = 0; j < 15; j++)

tickets.push_back(i);

break;

default:

break;

}

}

if (!tickets.size())

{

out.printerr("No units are eligible to enter a mood!\n");

return CR_FAILURE;

}

unit = moodable_units[tickets[rng.df_trandom(tickets.size())]];

}

df::unit_soul *soul = unit->status.current_soul;

// Cancel selected unit's current job

if (unit->job.current_job)

{

// TODO: cancel job

out.printerr("Chosen unit '{}' has active job, cannot start mood!\n",

DF2CONSOLE(Units::getReadableName(unit)).c_str());

return CR_FAILURE;

}

plotinfo->mood_cooldown = 1000;

// If no mood type was specified, pick one randomly

if (type == mood_type::None)

{

if (soul && (

(soul->personality.longterm_stress >= 100000) ||

(soul->personality.longterm_stress >= 50000 && !rng.df_trandom(2)) ||

(soul->personality.longterm_stress >= 20000 && !rng.df_trandom(10))

))

{

switch (rng.df_trandom(2))

{

case 0: type = mood_type::Fell; break;

case 1: type = mood_type::Macabre; break;

}

}

else

{

switch (rng.df_trandom(3))

{

case 0: type = mood_type::Fey; break;

case 1: type = mood_type::Secretive; break;

case 2: type = mood_type::Possessed; break;

}

}

}

// Display announcement and start setting up the mood job

int color = 0;

bool bright = false;

string msg = Units::getReadableName(unit);

switch (type)

{

case mood_type::Fey:

color = 7;

bright = true;

msg += " is taken by a fey mood!";

break;

case mood_type::Secretive:

color = 7;

bright = false;

msg += " withdraws from society...";

break;

case mood_type::Possessed:

color = 5;

bright = true;

msg += " has been possessed!";

break;

case mood_type::Macabre:

color = 0;

bright = true;

msg += " begins to stalk and brood...";

break;

case mood_type::Fell:

color = 5;

bright = false;

msg += " looses a roaring laughter, fell and terrible!";

break;

default:

out.printerr("Invalid mood type selected?\n");

return CR_FAILURE;

}

unit->mood = type;

unit->mood_copy = unit->mood;

Gui::showAutoAnnouncement(announcement_type::STRANGE_MOOD, unit->pos, msg, color, bright);

// TODO: make sure unit drops any wrestle items

unit->job.mood_timeout = 50000;

unit->flags1.bits.has_mood = true;

unit->flags1.bits.had_mood = true;

if (skill == job_skill::NONE)

skill = getMoodSkill(unit);

unit->job.mood_skill = skill;

df::job *job = new df::job();

Job::linkIntoWorld(job);

// Choose the job type

if (unit->mood == mood_type::Fell)

job->job_type = job_type::StrangeMoodFell;

else if (unit->mood == mood_type::Macabre)

job->job_type = job_type::StrangeMoodBrooding;

else

{

switch (skill)

{

case job_skill::MINING:

case job_skill::MASONRY:

case job_skill::CUT_STONE:

case job_skill::CARVE_STONE:

job->job_type = job_type::StrangeMoodMason;

break;

case job_skill::CARPENTRY:

job->job_type = job_type::StrangeMoodCarpenter;

break;

case job_skill::ENGRAVE_STONE:

case job_skill::WOODCRAFT:

case job_skill::STONECRAFT:

case job_skill::BONECARVE:

case job_skill::PAPERMAKING: // These aren't actually moodable skills

case job_skill::BOOKBINDING: // but the game still checks for them anyways

job->job_type = job_type::StrangeMoodCrafter;

break;

case job_skill::TANNER:

case job_skill::LEATHERWORK:

job->job_type = job_type::StrangeMoodTanner;

break;

case job_skill::WEAVING:

case job_skill::CLOTHESMAKING:

job->job_type = job_type::StrangeMoodWeaver;

break;

case job_skill::FORGE_WEAPON:

case job_skill::FORGE_ARMOR:

case job_skill::FORGE_FURNITURE:

case job_skill::METALCRAFT:

job->job_type = job_type::StrangeMoodForge;

break;

case job_skill::CUTGEM:

case job_skill::ENCRUSTGEM:

job->job_type = job_type::StrangeMoodJeweller;

break;

case job_skill::GLASSMAKER:

job->job_type = job_type::StrangeMoodGlassmaker;

break;

case job_skill::BOWYER:

job->job_type = job_type::StrangeMoodBowyer;

break;

case job_skill::MECHANICS:

job->job_type = job_type::StrangeMoodMechanics;

break;

default:

break;

}

}

// Check which types of glass are available - we'll need this information later

bool have_glass[3] = {false, false, false};

for (size_t i = 0; i < created_item_type->size(); i++)

{

if (created_item_type->at(i) == item_type::ROUGH)

{

switch (created_item_mattype->at(i))

{

case builtin_mats::GLASS_GREEN:

have_glass[0] = true;

break;

case builtin_mats::GLASS_CLEAR:

have_glass[1] = true;

break;

case builtin_mats::GLASS_CRYSTAL:

have_glass[2] = true;

break;

}

}

}

// The dwarf will want 1-3 of the base material

int base_item_count = 1 + rng.df_trandom(3);

// Gem Cutters and Gem Setters have a 50% chance of using only one base item

if (((skill == job_skill::CUTGEM) || (skill == job_skill::ENCRUSTGEM)) && (rng.df_trandom(2)))

base_item_count = 1;

// Choose the base material

df::job_item *item;

if (job->job_type == job_type::StrangeMoodFell)

{

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::CORPSE;

item->flags1.bits.allow_buryable = true;

item->flags1.bits.murdered = true;

item->quantity = 1;

item->vector_id = job_item_vector_id::ANY_MURDERED;

}

else if (job->job_type == job_type::StrangeMoodBrooding)

{

switch (rng.df_trandom(3))

{

case 0:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::REMAINS;

item->flags1.bits.allow_buryable = true;

item->quantity = base_item_count;

break;

case 1:

job->job_items.elements.push_back(item = new df::job_item());

item->flags1.bits.allow_buryable = true;

item->flags2.bits.bone = true;

item->flags2.bits.body_part = true;

item->quantity = base_item_count;

break;

case 2:

job->job_items.elements.push_back(item = new df::job_item());

item->flags1.bits.allow_buryable = true;

item->flags2.bits.totemable = true;

item->flags2.bits.body_part = true;

item->quantity = base_item_count;

break;

}

}

else

{

df::item *filter;

bool found_pref;

switch (skill)

{

case job_skill::MINING:

case job_skill::ENGRAVE_STONE:

case job_skill::MASONRY:

case job_skill::STONECRAFT:

case job_skill::MECHANICS:

case job_skill::CUT_STONE:

case job_skill::CARVE_STONE:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::BOULDER;

item->quantity = base_item_count;

item->flags3.bits.hard = true;

found_pref = false;

if (soul)

{

for (size_t i = 0; i < soul->preferences.size(); i++)

{

df::unit_preference *pref = soul->preferences[i];

if (pref->flags.bits.visible &&

pref->type == df::unitpref_type::LikeMaterial &&

pref->mattype == builtin_mats::INORGANIC)

{

item->mat_type = pref->mattype;

found_pref = true;

break;

}

}

}

if (!found_pref)

item->mat_type = builtin_mats::INORGANIC;

break;

case job_skill::CARPENTRY:

case job_skill::WOODCRAFT:

case job_skill::BOWYER:

case job_skill::PAPERMAKING:

case job_skill::BOOKBINDING:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::WOOD;

item->quantity = base_item_count;

break;

case job_skill::TANNER:

case job_skill::LEATHERWORK:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::SKIN_TANNED;

item->quantity = base_item_count;

break;

case job_skill::WEAVING:

case job_skill::CLOTHESMAKING:

filter = NULL;

for (auto chest_item : world->items.other[items_other_id::ANY_GOES_IN_CHEST]) {

filter = chest_item;

if (filter->getType() != item_type::CLOTH)

{

filter = NULL;

continue;

}

if (filter->getMaterial() != 0)

{

filter = NULL;

continue;

}

if (filter->getTotalDimension() < 10000)

{

filter = NULL;

continue;

}

MaterialInfo mat(filter->getMaterial(), filter->getMaterialIndex());

if (!mat.inorganic->flags.is_set(inorganic_flags::DEEP_SPECIAL))

{

filter = NULL;

continue;

}

break;

}

if (filter)

{

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::CLOTH;

item->mat_type = filter->getMaterial();

item->mat_index = filter->getMaterialIndex();

item->quantity = base_item_count * 10000;

item->min_dimension = 10000;

}

else

{

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::CLOTH;

bool found_pref = false;

if (soul)

{

for (size_t i = 0; i < soul->preferences.size(); i++)

{

df::unit_preference *pref = soul->preferences[i];

if (pref->flags.bits.visible &&

pref->type == df::unitpref_type::LikeMaterial)

{

MaterialInfo mat(pref->mattype, pref->matindex);

if (mat.material->flags.is_set(material_flags::SILK))

item->flags2.bits.silk = true;

else if (mat.material->flags.is_set(material_flags::THREAD_PLANT))

item->flags2.bits.plant = true;

else if (mat.material->flags.is_set(material_flags::YARN))

item->flags2.bits.yarn = true;

else

continue;

found_pref = true;

break;

}

}

}

if (!found_pref)

{

switch (rng.df_trandom(3))

{

case 0:

item->flags2.bits.silk = true;

break;

case 1:

item->flags2.bits.plant = true;

break;

case 2:

item->flags2.bits.yarn = true;

break;

}

}

item->quantity = base_item_count * 10000;

item->min_dimension = 10000;

}

break;

case job_skill::FORGE_WEAPON:

case job_skill::FORGE_ARMOR:

// there are actually 2 distinct cases here, but they're identical

case job_skill::FORGE_FURNITURE:

case job_skill::METALCRAFT:

filter = NULL;

for (auto chest_item : world->items.other[items_other_id::ANY_GOES_IN_CHEST]) {

filter = chest_item;

if (filter->getType() != item_type::BAR)

{

filter = NULL;

continue;

}

if (filter->getMaterial() != 0)

{

filter = NULL;

continue;

}

MaterialInfo mat(filter->getMaterial(), filter->getMaterialIndex());

if (!mat.inorganic->flags.is_set(inorganic_flags::DEEP_SPECIAL))

{

filter = NULL;

continue;

}

break;

}

if (filter)

{

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::BAR;

item->mat_type = filter->getMaterial();

item->mat_index = filter->getMaterialIndex();

item->quantity = base_item_count * 150; // BUGFIX - the game does not adjust here!

item->min_dimension = 150;

}

else

{

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::BAR;

item->mat_type = 0;

vector<int32_t> mats;

if (soul)

{

for (size_t i = 0; i < soul->preferences.size(); i++)

{

df::unit_preference *pref = soul->preferences[i];

if (pref->flags.bits.visible &&

pref->type == df::unitpref_type::LikeMaterial &&

pref->mattype == 0 && getCreatedMetalBars(pref->matindex) > 0)

mats.push_back(pref->matindex);

}

}

if (mats.size())

item->mat_index = mats[rng.df_trandom(mats.size())];

item->quantity = base_item_count * 150; // BUGFIX - the game does not adjust here!

item->min_dimension = 150;

}

break;

case job_skill::CUTGEM:

case job_skill::ENCRUSTGEM:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::ROUGH;

item->mat_type = 0;

item->quantity = base_item_count;

break;

case job_skill::GLASSMAKER:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::ROUGH;

found_pref = false;

if (soul)

{

for (size_t i = 0; i < soul->preferences.size(); i++)

{

df::unit_preference *pref = soul->preferences[i];

if (pref->flags.bits.visible &&

pref->type == df::unitpref_type::LikeMaterial &&

((pref->mattype == builtin_mats::GLASS_GREEN) ||

(pref->mattype == builtin_mats::GLASS_CLEAR && have_glass[1]) ||

(pref->mattype == builtin_mats::GLASS_CRYSTAL && have_glass[2])))

{

item->mat_type = pref->mattype;

item->mat_index = pref->matindex;

found_pref = true;

}

}

}

if (!found_pref)

{

vector<int32_t> mats;

mats.push_back(builtin_mats::GLASS_GREEN);

if (have_glass[1])

mats.push_back(builtin_mats::GLASS_CLEAR);

if (have_glass[2])

mats.push_back(builtin_mats::GLASS_CRYSTAL);

item->mat_type = mats[rng.df_trandom(mats.size())];

}

item->quantity = base_item_count;

break;

case job_skill::BONECARVE:

found_pref = false;

if (soul)

{

for (size_t i = 0; i < soul->preferences.size(); i++)

{

df::unit_preference *pref = soul->preferences[i];

if (pref->flags.bits.visible &&

pref->type == df::unitpref_type::LikeMaterial)

{

MaterialInfo mat(pref->mattype, pref->matindex);

if (mat.material->flags.is_set(material_flags::BONE))

{

job->job_items.elements.push_back(item = new df::job_item());

item->flags2.bits.bone = true;

item->flags2.bits.body_part = true;

found_pref = true;

break;

}

else if (mat.material->flags.is_set(material_flags::SHELL))

{

job->job_items.elements.push_back(item = new df::job_item());

item->flags2.bits.shell = true;

item->flags2.bits.body_part = true;

found_pref = true;

break;

}

}

}

}

if (!found_pref)

{

job->job_items.elements.push_back(item = new df::job_item());

item->flags2.bits.bone = true;

item->flags2.bits.body_part = true;

found_pref = true;

}

item->quantity = base_item_count;

break;

default:

break;

}

}

// Choose additional mood materials

// Gem cutters/setters using a single gem require nothing else, and fell moods need only their corpse

if (!(

(((skill == job_skill::CUTGEM) || (skill == job_skill::ENCRUSTGEM)) && base_item_count == 1) ||

(job->job_type == job_type::StrangeMoodFell)

))

{

int extra_items = std::min(rng.df_trandom((plotinfo->tasks.num_artifacts * 20 + moodable_units.size()) / 20 + 1), 7);

df::item_type avoid_type = item_type::NONE;

int avoid_glass = 0;

switch (skill)

{

case job_skill::MINING:

case job_skill::ENGRAVE_STONE:

case job_skill::MASONRY:

case job_skill::STONECRAFT:

case job_skill::CUT_STONE:

case job_skill::CARVE_STONE:

avoid_type = item_type::BLOCKS;

break;

case job_skill::CARPENTRY:

case job_skill::WOODCRAFT:

case job_skill::BOWYER:

avoid_type = item_type::WOOD;

break;

case job_skill::TANNER:

case job_skill::LEATHERWORK:

avoid_type = item_type::SKIN_TANNED;

break;

case job_skill::WEAVING:

case job_skill::CLOTHESMAKING:

avoid_type = item_type::CLOTH;

break;

case job_skill::FORGE_WEAPON:

case job_skill::FORGE_ARMOR:

case job_skill::FORGE_FURNITURE:

case job_skill::METALCRAFT:

avoid_type = item_type::BAR;

break;

case job_skill::CUTGEM:

case job_skill::ENCRUSTGEM:

avoid_type = item_type::SMALLGEM;

case job_skill::GLASSMAKER:

avoid_glass = 1;

break;

default:

break;

}

for (int i = 0; i < extra_items; i++)

{

if ((job->job_type == job_type::StrangeMoodBrooding) && (rng.df_trandom(2)))

{

switch (rng.df_trandom(2))

{

case 0:

job->job_items.elements.push_back(item = new df::job_item());

item->item_type = item_type::REMAINS;

item->flags1.bits.allow_buryable = true;

item->quantity = 1;

break;

case 1:

job->job_items.elements.push_back(item = new df::job_item());

item->flags1.bits.allow_buryable = true;

item->flags2.bits.bone = true;

item->flags2.bits.body_part = true;

item->quantity = 1;

break;

}

}

else

{

df::item_type item_type;

int16_t mat_type;

df::job_item_flags2 flags2;

do

{

item_type = item_type::NONE;

mat_type = -1;

flags2.whole = 0;

switch (rng.df_trandom(10))

{

case 0: