/*

https://github.com/peterix/dfhack

Copyright (c) 2009-2012 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 <stddef.h>

#include <string>

#include <vector>

#include <map>

#include <cstring>

#include <algorithm>

#include <numeric>

#include <functional>

using namespace std;

#include "VersionInfo.h"

#include "MemAccess.h"

#include "Error.h"

#include "Types.h"

// we connect to those

#include "modules/Units.h"

#include "modules/Items.h"

#include "modules/Maps.h"

#include "modules/Materials.h"

#include "modules/Translation.h"

#include "ModuleFactory.h"

#include "Core.h"

#include "MiscUtils.h"

#include "df/activity_entry.h"

#include "df/burrow.h"

#include "df/caste_raw.h"

#include "df/creature_raw.h"

#include "df/curse_attr_change.h"

#include "df/entity_position.h"

#include "df/entity_position_assignment.h"

#include "df/entity_raw.h"

#include "df/entity_raw_flags.h"

#include "df/identity_type.h"

#include "df/game_mode.h"

#include "df/histfig_entity_link_positionst.h"

#include "df/histfig_relationship_type.h"

#include "df/historical_entity.h"

#include "df/historical_figure.h"

#include "df/historical_figure_info.h"

#include "df/historical_kills.h"

#include "df/history_event_hist_figure_diedst.h"

#include "df/identity.h"

#include "df/job.h"

#include "df/nemesis_record.h"

#include "df/squad.h"

#include "df/tile_occupancy.h"

#include "df/ui.h"

#include "df/unit_inventory_item.h"

#include "df/unit_misc_trait.h"

#include "df/unit_relationship_type.h"

#include "df/unit_skill.h"

#include "df/unit_soul.h"

#include "df/unit_wound.h"

#include "df/world.h"

#include "df/unit_action.h"

#include "df/unit_action_type_group.h"

using namespace DFHack;

using namespace df::enums;

using df::global::world;

using df::global::ui;

using df::global::gamemode;

using df::global::gametype;

bool Units::isUnitInBox(df::unit* u,

int16_t x1, int16_t y1, int16_t z1,

int16_t x2, int16_t y2, int16_t z2) {

if (x1 > x2) swap(x1, x2);

if (y1 > y2) swap(y1, y2);

if (z1 > z2) swap(z1, z2);

if (u->pos.x >= x1 && u->pos.x <= x2) {

if (u->pos.y >= y1 && u->pos.y <= y2) {

if (u->pos.z >= z1 && u->pos.z <= z2) {

return true;

}

}

}

return false;

}

bool Units::isActive(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return !unit->flags1.bits.inactive;

}

bool Units::isVisible(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return Maps::isTileVisible(unit->pos);

}

bool Units::isCitizen(df::unit *unit, bool ignore_sanity)

{

CHECK_NULL_POINTER(unit);

// Copied from the conditions used to decide game over,

// except that the game appears to let melancholy/raving

// dwarves count as citizens.

if (unit->flags1.bits.marauder ||

unit->flags1.bits.invader_origin ||

unit->flags1.bits.active_invader ||

unit->flags1.bits.forest ||

unit->flags1.bits.merchant ||

unit->flags1.bits.diplomat ||

unit->flags2.bits.visitor ||

unit->flags2.bits.visitor_uninvited ||

unit->flags2.bits.underworld ||

unit->flags2.bits.resident)

return false;

if (!ignore_sanity && !isSane(unit))

return false;

return isOwnGroup(unit);

}

bool Units::isFortControlled(df::unit *unit)

{ // Reverse-engineered from ambushing unit code

CHECK_NULL_POINTER(unit);

if (*gamemode != game_mode::DWARF)

return false;

if (unit->mood == mood_type::Berserk ||

Units::isCrazed(unit) ||

Units::isOpposedToLife(unit) ||

unit->enemy.undead ||

unit->flags3.bits.ghostly)

return false;

if (unit->flags1.bits.marauder ||

unit->flags1.bits.invader_origin ||

unit->flags1.bits.active_invader ||

unit->flags1.bits.forest ||

unit->flags1.bits.merchant ||

unit->flags1.bits.diplomat)

return false;

if (unit->flags1.bits.tame)

return true;

if (unit->flags2.bits.visitor ||

unit->flags2.bits.visitor_uninvited ||

unit->flags2.bits.underworld ||

unit->flags2.bits.resident)

return false;

return unit->civ_id != -1 && unit->civ_id == ui->civ_id;

}

// check if creature belongs to the player's civilization

// (don't try to pasture/slaughter random untame animals)

bool Units::isOwnCiv(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->civ_id == ui->civ_id;

}

// check if creature belongs to the player's group

bool Units::isOwnGroup(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

auto histfig = df::historical_figure::find(unit->hist_figure_id);

if (!histfig)

return false;

for (size_t i = 0; i < histfig->entity_links.size(); i++)

{

auto link = histfig->entity_links[i];

if (link->entity_id == ui->group_id && link->getType() == df::histfig_entity_link_type::MEMBER)

return true;

}

return false;

}

// check if creature belongs to the player's race

// (in combination with check for civ helps to filter out own dwarves)

bool Units::isOwnRace(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->race == ui->race_id;

}

bool Units::isAlive(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return !unit->flags2.bits.killed &&

!unit->flags3.bits.ghostly &&

!unit->curse.add_tags1.bits.NOT_LIVING;

}

bool Units::isDead(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags2.bits.killed ||

unit->flags3.bits.ghostly;

}

bool Units::isKilled(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags2.bits.killed;

}

bool Units::isSane(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (isDead(unit) ||

isOpposedToLife(unit) ||

unit->enemy.undead)

return false;

if (unit->enemy.normal_race == unit->enemy.were_race && isCrazed(unit))

return false;

switch (unit->mood)

{

case mood_type::Melancholy:

case mood_type::Raving:

case mood_type::Berserk:

return false;

default:

break;

}

return true;

}

bool Units::isCrazed(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->flags3.bits.scuttle)

return false;

if (unit->curse.rem_tags1.bits.CRAZED)

return false;

if (unit->curse.add_tags1.bits.CRAZED)

return true;

return casteFlagSet(unit->race, unit->caste, caste_raw_flags::CRAZED);

}

bool Units::isGhost(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags3.bits.ghostly;

}

bool Units::isHidden(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

// Reverse-engineered from ambushing unit code

if (*df::global::debug_showambush)

return false;

if (*gamemode == game_mode::ADVENTURE)

{

if (unit == world->units.active[0])

return false;

else if (unit->flags1.bits.hidden_in_ambush)

return true;

}

else

{

if (*gametype == game_type::DWARF_ARENA)

return false;

else if (unit->flags1.bits.hidden_in_ambush && !isFortControlled(unit))

return true;

}

if (unit->flags1.bits.caged)

{

auto spec_ref = getOuterContainerRef(unit);

if (spec_ref.type == specific_ref_type::UNIT)

return isHidden(spec_ref.data.unit);

}

if (*gamemode == game_mode::ADVENTURE || isFortControlled(unit))

return false;

else

return !Maps::isTileVisible(Units::getPosition(unit));

}

bool Units::isHidingCurse(df::unit *unit)

{

if (!unit->job.hunt_target)

{

auto identity = Units::getIdentity(unit);

if (identity && identity->type == df::identity_type::HidingCurse)

return true;

}

return false;

}

bool Units::isMale(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->sex == 1;

}

bool Units::isFemale(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->sex == 0;

}

bool Units::isBaby(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->profession == df::profession::BABY;

}

bool Units::isChild(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->profession == df::profession::CHILD;

}

bool Units::isAdult(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return !isBaby(unit) && !isChild(unit);

}

bool Units::isGay(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

if (!unit->status.current_soul)

return false;

df::orientation_flags orientation = unit->status.current_soul->orientation_flags;

return (!Units::isFemale(unit) || !(orientation.whole & (orientation.mask_marry_male | orientation.mask_romance_male)))

&& (!Units::isMale(unit) || !(orientation.whole & (orientation.mask_marry_female | orientation.mask_romance_female)));

}

bool Units::isNaked(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

// TODO(kazimuth): is this correct?

return (unit->inventory.empty());

}

bool Units::isVisiting(df::unit* unit) {

CHECK_NULL_POINTER(unit);

return unit->flags1.bits.merchant ||

unit->flags1.bits.diplomat ||

unit->flags2.bits.visitor ||

unit->flags2.bits.visitor_uninvited;

}

bool Units::isTrainableHunting(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::TRAINABLE_HUNTING);

}

bool Units::isTrainableWar(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::TRAINABLE_WAR);

}

bool Units::isTrained(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

// case a: trained for war/hunting (those don't have a training level, strangely)

if(Units::isWar(unit) || Units::isHunter(unit))

return true;

// case b: tamed and trained wild creature, gets a training level

bool trained = false;

switch (unit->training_level)

{

case df::animal_training_level::Trained:

case df::animal_training_level::WellTrained:

case df::animal_training_level::SkilfullyTrained:

case df::animal_training_level::ExpertlyTrained:

case df::animal_training_level::ExceptionallyTrained:

case df::animal_training_level::MasterfullyTrained:

//case df::animal_training_level::Domesticated:

trained = true;

break;

default:

break;

}

return trained;

}

// check for profession "hunting creature"

bool Units::isHunter(df::unit* unit)

{

CHECK_NULL_POINTER(unit)

return unit->profession == df::profession::TRAINED_HUNTER

|| unit->profession2 == df::profession::TRAINED_HUNTER;

}

// check for profession "war creature"

bool Units::isWar(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->profession == df::profession::TRAINED_WAR

|| unit->profession2 == df::profession::TRAINED_WAR;

}

bool Units::isTame(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

bool tame = false;

if(unit->flags1.bits.tame)

{

switch (unit->training_level)

{

case df::animal_training_level::SemiWild: //??

case df::animal_training_level::Trained:

case df::animal_training_level::WellTrained:

case df::animal_training_level::SkilfullyTrained:

case df::animal_training_level::ExpertlyTrained:

case df::animal_training_level::ExceptionallyTrained:

case df::animal_training_level::MasterfullyTrained:

case df::animal_training_level::Domesticated:

tame=true;

break;

case df::animal_training_level::Unk8: //??

case df::animal_training_level::WildUntamed:

default:

tame=false;

break;

}

}

return tame;

}

bool Units::isTamable(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::PET)

|| caste->flags.is_set(caste_raw_flags::PET_EXOTIC);

}

// check if creature is domesticated

// seems to be the only way to really tell if it's completely safe to autonestbox it (training can revert)

bool Units::isDomesticated(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

bool tame = false;

if(unit->flags1.bits.tame)

{

switch (unit->training_level)

{

case df::animal_training_level::Domesticated:

tame=true;

break;

default:

tame=false;

break;

}

}

return tame;

}

bool Units::isMarkedForSlaughter(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags2.bits.slaughter == 1;

}

bool Units::isGelded(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

auto wounds = unit->body.wounds;

for(auto wound = wounds.begin(); wound != wounds.end(); ++wound)

{

auto parts = (*wound)->parts;

for (auto part = parts.begin(); part != parts.end(); ++part)

{

if ((*part)->flags2.bits.gelded)

return true;

}

}

return false;

}

bool Units::isEggLayer(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::LAYS_EGGS)

|| caste->flags.is_set(caste_raw_flags::LAYS_UNUSUAL_EGGS);

}

bool Units::isGrazer(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::GRAZER);

}

bool Units::isMilkable(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

df::creature_raw *raw = world->raws.creatures.all[unit->race];

df::caste_raw *caste = raw->caste.at(unit->caste);

return caste->flags.is_set(caste_raw_flags::MILKABLE);

}

bool Units::isForest(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags1.bits.forest == 1;

}

bool Units::isMischievous(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->curse.rem_tags1.bits.MISCHIEVOUS)

return false;

if (unit->curse.add_tags1.bits.MISCHIEVOUS)

return true;

return casteFlagSet(unit->race, unit->caste, caste_raw_flags::MISCHIEVOUS);

}

// check if unit is marked as available for adoption

bool Units::isAvailableForAdoption(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

auto refs = unit->specific_refs;

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

{

auto ref = refs[i];

auto reftype = ref->type;

if( reftype == df::specific_ref_type::PETINFO_PET )

{

//df::pet_info* pet = ref->pet;

return true;

}

}

return false;

}

bool Units::hasExtravision(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->curse.rem_tags1.bits.EXTRAVISION)

return false;

if (unit->curse.add_tags1.bits.EXTRAVISION)

return true;

return casteFlagSet(unit->race, unit->caste, caste_raw_flags::EXTRAVISION);

}

bool Units::isOpposedToLife(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->curse.rem_tags1.bits.OPPOSED_TO_LIFE)

return false;

if (unit->curse.add_tags1.bits.OPPOSED_TO_LIFE)

return true;

return casteFlagSet(unit->race, unit->caste, caste_raw_flags::OPPOSED_TO_LIFE);

}

bool Units::isBloodsucker(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->curse.rem_tags1.bits.BLOODSUCKER)

return false;

if (unit->curse.add_tags1.bits.BLOODSUCKER)

return true;

return casteFlagSet(unit->race, unit->caste, caste_raw_flags::BLOODSUCKER);

}

bool Units::isDwarf(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return unit->race == ui->race_id ||

unit->enemy.normal_race == ui->race_id;

}

bool Units::isAnimal(df::unit* unit) {

CHECK_NULL_POINTER(unit)

using namespace df::enums::caste_raw_flags;

const auto &cf = unit->enemy.caste_flags;

// we're (somewhat) matching Dwarf Therapist's animal check. We care about wild animals too however.

return !cf.is_set(CAN_LEARN) && !cf.is_set(CAN_SPEAK) &&

(unit->flags2.bits.roaming_wilderness_population_source ||

cf.is_set(PET) ||

cf.is_set(PET_EXOTIC) ||

cf.is_set(TRAINABLE_WAR) || //These last two may be redundant

cf.is_set(TRAINABLE_HUNTING));

}

bool Units::isMerchant(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags1.bits.merchant == 1;

}

bool Units::isDiplomat(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags1.bits.diplomat == 1;

}

bool Units::isVisitor(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->flags2.bits.visitor || unit->flags2.bits.visitor_uninvited;

}

bool Units::isInvader(df::unit* unit) {

CHECK_NULL_POINTER(unit);

return !isOwnGroup(unit) &&

(unit->flags1.bits.marauder ||

unit->flags1.bits.invader_origin ||

unit->flags1.bits.active_invader);

}

bool Units::isUndead(df::unit* unit, bool include_vamps)

{

CHECK_NULL_POINTER(unit);

const auto &cb = unit->curse.add_tags1.bits;

return unit->flags3.bits.ghostly ||

((cb.OPPOSED_TO_LIFE || cb.NOT_LIVING) && (include_vamps || !cb.BLOODSUCKER));

}

bool Units::isNightCreature(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->enemy.caste_flags.is_set(df::enums::caste_raw_flags::NIGHT_CREATURE);

}

bool Units::isSemiMegabeast(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->enemy.caste_flags.is_set(df::enums::caste_raw_flags::SEMIMEGABEAST);

}

bool Units::isMegabeast(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->enemy.caste_flags.is_set(df::enums::caste_raw_flags::MEGABEAST);

}

bool Units::isTitan(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return unit->enemy.caste_flags.is_set(df::enums::caste_raw_flags::TITAN);

}

bool Units::isDemon(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

using namespace df::enums::caste_raw_flags;

const auto &cf = unit->enemy.caste_flags;

return cf.is_set(DEMON) || cf.is_set(UNIQUE_DEMON);

}

bool Units::isDanger(df::unit* unit) {

CHECK_NULL_POINTER(unit);

return isCrazed(unit) ||

isInvader(unit) ||

isUndead(unit, true) ||

isSemiMegabeast(unit) ||

isNightCreature(unit) ||

isGreatDanger(unit);

}

bool Units::isGreatDanger(df::unit* unit)

{

CHECK_NULL_POINTER(unit);

return isDemon(unit) || isTitan(unit) || isMegabeast(unit);

}

int32_t Units::getNumUnits()

{

return world->units.all.size();

}

df::unit *Units::getUnit (const int32_t index)

{

return vector_get(world->units.all, index);

}

// returns index of creature actually read or -1 if no creature can be found

bool Units::getUnitsInBox (std::vector<df::unit*> &units,

int16_t x1, int16_t y1, int16_t z1,

int16_t x2, int16_t y2, int16_t z2)

{

if (!world)

return false;

units.clear();

for (df::unit *u : world->units.all)

{

if (isUnitInBox(u, x1, y1, z1, x2, y2, z2))

{

units.push_back(u);

}

}

return true;

}

int32_t Units::findIndexById(int32_t creature_id)

{

return df::unit::binsearch_index(world->units.all, creature_id);

}

df::coord Units::getPosition(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

if (unit->flags1.bits.caged)

{

auto cage = getContainer(unit);

if (cage)

return Items::getPosition(cage);

}

return unit->pos;

}

bool Units::teleport(df::unit *unit, df::coord target_pos)

{

// make sure source and dest map blocks are valid

auto old_occ = Maps::getTileOccupancy(unit->pos);

auto new_occ = Maps::getTileOccupancy(target_pos);

if (!old_occ || !new_occ)

return false;

// clear appropriate occupancy flags at old tile

if (unit->flags1.bits.on_ground)

// this is potentially wrong, but the game will recompute this as needed

old_occ->bits.unit_grounded = 0;

else

old_occ->bits.unit = 0;

// if there's already somebody standing at the destination, then force the

// unit to lay down

if (new_occ->bits.unit)

unit->flags1.bits.on_ground = 1;

// set appropriate occupancy flags at new tile

if (unit->flags1.bits.on_ground)

new_occ->bits.unit_grounded = 1;

else

new_occ->bits.unit = 1;

// move unit to destination

unit->pos = target_pos;

unit->idle_area = target_pos;

// move unit's riders (including babies) to destination

if (unit->flags1.bits.ridden)

{

for (size_t j = 0; j < world->units.other[units_other_id::ANY_RIDER].size(); j++)

{

df::unit *rider = world->units.other[units_other_id::ANY_RIDER][j];

if (rider->relationship_ids[df::unit_relationship_type::RiderMount] == unit->id)

rider->pos = unit->pos;

}

}

return true;

}

df::general_ref *Units::getGeneralRef(df::unit *unit, df::general_ref_type type)

{

CHECK_NULL_POINTER(unit);

return findRef(unit->general_refs, type);

}

df::specific_ref *Units::getSpecificRef(df::unit *unit, df::specific_ref_type type)

{

CHECK_NULL_POINTER(unit);

return findRef(unit->specific_refs, type);

}

df::item *Units::getContainer(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

return findItemRef(unit->general_refs, general_ref_type::CONTAINED_IN_ITEM);

}

void Units::getOuterContainerRef(df::specific_ref &spec_ref, df::unit *unit, bool init_ref)

{

CHECK_NULL_POINTER(unit);

// Reverse-engineered from ambushing unit code

if (init_ref)

{

spec_ref.type = specific_ref_type::UNIT;

spec_ref.data.unit = unit;

}

if (unit->flags1.bits.caged)

{

df::item *cage = getContainer(unit);

if (cage)

return Items::getOuterContainerRef(spec_ref, cage);

}

return;

}

static df::identity *getFigureIdentity(df::historical_figure *figure)

{

if (figure && figure->info && figure->info->reputation)

return df::identity::find(figure->info->reputation->cur_identity);

return NULL;

}

df::identity *Units::getIdentity(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

df::historical_figure *figure = df::historical_figure::find(unit->hist_figure_id);

return getFigureIdentity(figure);

}

void Units::setNickname(df::unit *unit, std::string nick)

{

CHECK_NULL_POINTER(unit);

// There are >=3 copies of the name, and the one

// in the unit is not the authoritative one.

// This is the reason why military units often

// lose nicknames set from Dwarf Therapist.

Translation::setNickname(&unit->name, nick);

if (unit->status.current_soul)

Translation::setNickname(&unit->status.current_soul->name, nick);

df::historical_figure *figure = df::historical_figure::find(unit->hist_figure_id);

if (figure)

{

Translation::setNickname(&figure->name, nick);

if (auto identity = getFigureIdentity(figure))

{

df::historical_figure *id_hfig = NULL;

switch (identity->type) {

case df::identity_type::None:

case df::identity_type::HidingCurse:

case df::identity_type::FalseIdentity:

case df::identity_type::InfiltrationIdentity:

case df::identity_type::Identity:

break; // We want the nickname to end up in the identity

case df::identity_type::Impersonating:

case df::identity_type::TrueName:

id_hfig = df::historical_figure::find(identity->histfig_id);

break;

}

if (id_hfig)

{

Translation::setNickname(&id_hfig->name, nick);

}

else

Translation::setNickname(&identity->name, nick);

}

}

}

df::language_name *Units::getVisibleName(df::unit *unit)

{

CHECK_NULL_POINTER(unit);

// as of 0.44.11, identity names take precedence over associated histfig names

if (auto identity = getIdentity(unit))

return &identity->name;

return &unit->name;

}

df::nemesis_record *Units::getNemesis(df::unit *unit)

{

if (!unit)

return NULL;

for (unsigned i = 0; i < unit->general_refs.size(); i++)

{

df::nemesis_record *rv = unit->general_refs[i]->getNemesis();

if (rv && rv->unit == unit)

return rv;

}

return NULL;

}

int Units::getPhysicalAttrValue(df::unit *unit, df::physical_attribute_type attr)

{

auto &aobj = unit->body.physical_attrs[attr];

int value = std::max(0, aobj.value - aobj.soft_demotion);

if (auto mod = unit->curse.attr_change)

{

int mvalue = (value * mod->phys_att_perc[attr] / 100) + mod->phys_att_add[attr];

if (isHidingCurse(unit))

value = std::min(value, mvalue);

else

value = mvalue;

}

return std::max(0, value);

}

int Units::getMentalAttrValue(df::unit *unit, df::mental_attribute_type attr)

{

auto soul = unit->status.current_soul;

if (!soul) return 0;

auto &aobj = soul->mental_attrs[attr];

int value = std::max(0, aobj.value - aobj.soft_demotion);

if (auto mod = unit->curse.attr_change)

{

int mvalue = (value * mod->ment_att_perc[attr] / 100) + mod->ment_att_add[attr];

if (isHidingCurse(unit))

value = std::min(value, mvalue);

else

value = mvalue;

}

return std::max(0, value);

}

bool Units::casteFlagSet(int race, int caste, df::caste_raw_flags flag)

{

auto creature = df::creature_raw::find(race);

if (!creature)

return false;

auto craw = vector_get(creature->caste, caste);

if (!craw)

return false;