int monster::bash_at(int x, int y) {
if (has_effect("pacified")) return 0;
//Hallucinations can't bash stuff.
if(is_hallucination()) {
return 0;
}
bool try_bash = !can_move_to(x, y) || one_in(3);
bool can_bash = g->m.is_bashable(x, y) && (has_flag(MF_BASHES) || has_flag(MF_BORES));
if( try_bash && can_bash ) {
int bashskill = group_bash_skill( point(x, y) );
g->m.bash( x, y, bashskill );
moves -= 100;
return 1;
}
return 0;
}
monster_attitude monster::attitude(player *u)
{
if (friendly != 0)
return MATT_FRIEND;
if (has_effect(ME_RUN))
return MATT_FLEE;
int effective_anger = anger;
int effective_morale = morale;
if (u != NULL) {
if (((type->species == species_mammal && u->has_trait(PF_PHEROMONE_MAMMAL)) ||
(type->species == species_insect && u->has_trait(PF_PHEROMONE_INSECT)))&&
effective_anger >= 10)
effective_anger -= 20;
if (u->has_trait(PF_TERRIFYING))
effective_morale -= 10;
if (u->has_trait(PF_ANIMALEMPATH) && has_flag(MF_ANIMAL)) {
if (effective_anger >= 10)
effective_anger -= 10;
if (effective_anger < 10)
effective_morale += 5;
}
}
if (effective_morale < 0) {
if (effective_morale + effective_anger > 0)
return MATT_FOLLOW;
return MATT_FLEE;
}
if (effective_anger < 0)
return MATT_IGNORE;
if (effective_anger < 10)
return MATT_FOLLOW;
return MATT_ATTACK;
}
nc_color monster::color_with_effects() const
{
nc_color ret = type->color;
if (has_effect("beartrap") || has_effect("stunned") || has_effect("downed") || has_effect("tied")) {
ret = hilite(ret);
}
if (has_effect("pacified")) {
ret = invert_color(ret);
}
if (has_effect("onfire")) {
ret = red_background(ret);
}
return ret;
}
void monster::move_to(game *g, int x, int y)
{
int mondex = g->mon_at(x, y);
if (mondex == -1) { //...assuming there's no monster there
if (has_effect(ME_BEARTRAP)) {
moves = 0;
return;
}
if (plans.size() > 0)
plans.erase(plans.begin());
if (has_flag(MF_SWIMS) && g->m.has_flag(swimmable, x, y))
moves += 50;
if (!has_flag(MF_DIGS) && !has_flag(MF_FLIES) &&
(!has_flag(MF_SWIMS) || !g->m.has_flag(swimmable, x, y)))
moves -= (g->m.move_cost(x, y) - 2) * 50;
posx = x;
posy = y;
footsteps(g, x, y);
if (g->m.has_flag(sharp, posx, posy) && !one_in(4))
hurt(rng(2, 3));
if (g->m.has_flag(rough, posx, posy) && one_in(6))
hurt(rng(1, 2));
if (!has_flag(MF_DIGS) && !has_flag(MF_FLIES) &&
g->m.tr_at(posx, posy) != tr_null) { // Monster stepped on a trap!
trap* tr = g->traps[g->m.tr_at(posx, posy)];
if (dice(3, sk_dodge + 1) < dice(3, tr->avoidance)) {
trapfuncm f;
(f.*(tr->actm))(g, this, posx, posy);
}
}
// Diggers turn the dirt into dirtmound
if (has_flag(MF_DIGS))
g->m.ter(posx, posy) = t_dirtmound;
// Acid trail monsters leave... a trail of acid
if (has_flag(MF_ACIDTRAIL))
g->m.add_field(g, posx, posy, fd_acid, 1);
} else if (has_flag(MF_ATTACKMON) || g->z[mondex].friendly != 0)
// If there IS a monster there, and we fight monsters, fight it!
hit_monster(g, mondex);
}
bool Creature::remove_effect( const efftype_id &eff_id, body_part bp )
{
if (!has_effect(eff_id, bp)) {
//Effect doesn't exist, so do nothing
return false;
}
const effect_type &type = eff_id.obj();
if (is_player()) {
// Print the removal message and add the memorial log if needed
if( !type.get_remove_message().empty() ) {
add_msg(type.lose_game_message_type(),
_(type.get_remove_message().c_str()));
}
add_memorial_log(pgettext("memorial_male",
type.get_remove_memorial_log().c_str()),
pgettext("memorial_female",
type.get_remove_memorial_log().c_str()));
}
// num_bp means remove all of a given effect id
if (bp == num_bp) {
for( auto &it : ( *effects )[eff_id] ) {
on_effect_int_change( eff_id, 0, it.first );
}
effects->erase(eff_id);
} else {
( *effects )[eff_id].erase(bp);
on_effect_int_change( eff_id, 0, bp );
// If there are no more effects of a given type remove the type map
if (( *effects )[eff_id].empty()) {
effects->erase(eff_id);
}
}
return true;
}
void monster::print_info(game *g, WINDOW* w)
{
// First line of w is the border; the next two are terrain info, and after that
// is a blank line. w is 13 characters tall, and we can't use the last one
// because it's a border as well; so we have lines 4 through 11.
// w is also 48 characters wide - 2 characters for border = 46 characters for us
mvwprintz(w, 6, 1, c_white, "%s ", type->name.c_str());
switch (attitude(&(g->u))) {
case MATT_FRIEND:
wprintz(w, h_white, "Friendly! ");
break;
case MATT_FLEE:
wprintz(w, c_green, "Fleeing! ");
break;
case MATT_IGNORE:
wprintz(w, c_ltgray, "Ignoring ");
break;
case MATT_FOLLOW:
wprintz(w, c_yellow, "Tracking ");
break;
case MATT_ATTACK:
wprintz(w, c_red, "Hostile! ");
break;
default:
wprintz(w, h_red, "BUG: Behavior unnamed ");
break;
}
if (has_effect(ME_DOWNED))
wprintz(w, h_white, "On ground");
else if (has_effect(ME_STUNNED))
wprintz(w, h_white, "Stunned");
else if (has_effect(ME_BEARTRAP))
wprintz(w, h_white, "Trapped");
std::string damage_info;
nc_color col;
if (hp == type->hp) {
damage_info = "It is uninjured";
col = c_green;
} else if (hp >= type->hp * .8) {
damage_info = "It is lightly injured";
col = c_ltgreen;
} else if (hp >= type->hp * .6) {
damage_info = "It is moderately injured";
col = c_yellow;
} else if (hp >= type->hp * .3) {
damage_info = "It is heavily injured";
col = c_yellow;
} else if (hp >= type->hp * .1) {
damage_info = "It is severly injured";
col = c_ltred;
} else {
damage_info = "it is nearly dead";
col = c_red;
}
mvwprintz(w, 7, 1, col, damage_info.c_str());
std::string tmp = type->description;
std::string out;
size_t pos;
int line = 8;
do {
pos = tmp.find_first_of('\n');
out = tmp.substr(0, pos);
mvwprintz(w, line, 1, c_white, out.c_str());
tmp = tmp.substr(pos + 1);
line++;
} while (pos != std::string::npos && line < 12);
}
bool monster::can_hear()
{
return has_flag(MF_HEARS) && !has_effect(ME_DEAF);
}
bool monster::move_to( const tripoint &p, bool force, const float stagger_adjustment )
{
const bool digs = digging();
const bool flies = has_flag( MF_FLIES );
const bool on_ground = !digs && !flies;
const bool climbs = has_flag( MF_CLIMBS ) && g->m.has_flag( TFLAG_NO_FLOOR, p );
// Allows climbing monsters to move on terrain with movecost <= 0
Creature *critter = g->critter_at( p, is_hallucination() );
if( g->m.has_flag( "CLIMBABLE", p ) ) {
if( g->m.impassable( p ) && critter == nullptr ) {
if( flies ) {
moves -= 100;
force = true;
if( g->u.sees( *this ) ) {
add_msg( _( "The %1$s flies over the %2$s." ), name().c_str(),
g->m.has_flag_furn( "CLIMBABLE", p ) ? g->m.furnname( p ).c_str() :
g->m.tername( p ).c_str() );
}
} else if( has_flag( MF_CLIMBS ) ) {
moves -= 150;
force = true;
if( g->u.sees( *this ) ) {
add_msg( _( "The %1$s climbs over the %2$s." ), name().c_str(),
g->m.has_flag_furn( "CLIMBABLE", p ) ? g->m.furnname( p ).c_str() :
g->m.tername( p ).c_str() );
}
}
}
}
if( critter != nullptr && !force ) {
return false;
}
// Make sure that we can move there, unless force is true.
if( !force && !can_move_to( p ) ) {
return false;
}
if( !force ) {
// This adjustment is to make it so that monster movement speed relative to the player
// is consistent even if the monster stumbles,
// and the same regardless of the distance measurement mode.
const int cost = stagger_adjustment *
( float )( climbs ? calc_climb_cost( pos(), p ) :
calc_movecost( pos(), p ) );
if( cost > 0 ) {
moves -= cost;
} else {
return false;
}
}
//Check for moving into/out of water
bool was_water = g->m.is_divable( pos() );
bool will_be_water = on_ground && can_submerge() && g->m.is_divable( p );
if( was_water && !will_be_water && g->u.sees( p ) ) {
//Use more dramatic messages for swimming monsters
add_msg( m_warning, _( "A %1$s %2$s from the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "leaps" ) : _( "emerges" ),
g->m.tername( pos() ).c_str() );
} else if( !was_water && will_be_water && g->u.sees( p ) ) {
add_msg( m_warning, _( "A %1$s %2$s into the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "dives" ) : _( "sinks" ),
g->m.tername( p ).c_str() );
}
setpos( p );
footsteps( p );
underwater = will_be_water;
if( is_hallucination() ) {
//Hallucinations don't do any of the stuff after this point
return true;
}
// TODO: Make tanks stop taking damage from rubble, because it's just silly
if( type->size != MS_TINY && on_ground ) {
if( g->m.has_flag( "SHARP", pos() ) && !one_in( 4 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 10 ) );
}
if( g->m.has_flag( "ROUGH", pos() ) && one_in( 6 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 2 ) );
}
}
if( g->m.has_flag( "UNSTABLE", p ) && on_ground ) {
add_effect( effect_bouldering, 1, num_bp, true );
} else if( has_effect( effect_bouldering ) ) {
remove_effect( effect_bouldering );
}
g->m.creature_on_trap( *this );
if( !will_be_water && ( has_flag( MF_DIGS ) || has_flag( MF_CAN_DIG ) ) ) {
underwater = g->m.has_flag( "DIGGABLE", pos() );
}
// Diggers turn the dirt into dirtmound
if( digging() ) {
int factor = 0;
switch( type->size ) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if( one_in( factor ) ) {
g->m.ter_set( pos(), t_dirtmound );
}
}
// Acid trail monsters leave... a trail of acid
if( has_flag( MF_ACIDTRAIL ) ) {
g->m.add_field( pos(), fd_acid, 3, 0 );
}
if( has_flag( MF_SLUDGETRAIL ) ) {
for( const tripoint &sludge_p : g->m.points_in_radius( pos(), 1 ) ) {
const int fstr = 3 - ( abs( sludge_p.x - posx() ) + abs( sludge_p.y - posy() ) );
if( fstr >= 2 ) {
g->m.add_field( sludge_p, fd_sludge, fstr, 0 );
}
}
}
return true;
}
bool monster::can_see()
{
return has_flag(MF_SEES) && !has_effect("blind");
}
int monster::move_to(int x, int y, bool force)
{
// Make sure that we can move there, unless force is true.
if(!force) if(!g->is_empty(x, y) || !can_move_to(x, y)) {
return 0;
}
if (has_effect("beartrap")) {
moves = 0;
return 0;
}
if (plans.size() > 0) {
plans.erase(plans.begin());
}
if (!force) {
moves -= calc_movecost(posx(), posy(), x, y);
}
//Check for moving into/out of water
bool was_water = g->m.is_divable(posx(), posy());
bool will_be_water = g->m.is_divable(x, y);
if(was_water && !will_be_water && g->u_see(x, y)) {
//Use more dramatic messages for swimming monsters
g->add_msg(_("A %s %s from the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("leaps") : _("emerges"),
g->m.tername(posx(), posy()).c_str());
} else if(!was_water && will_be_water && g->u_see(x, y)) {
g->add_msg(_("A %s %s into the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("dives") : _("sinks"),
g->m.tername(x, y).c_str());
}
setpos(x, y);
footsteps(x, y);
if(is_hallucination()) {
//Hallucinations don't do any of the stuff after this point
return 1;
}
if (type->size != MS_TINY && g->m.has_flag("SHARP", posx(), posy()) && !one_in(4)) {
hurt(rng(2, 3));
}
if (type->size != MS_TINY && g->m.has_flag("ROUGH", posx(), posy()) && one_in(6)) {
hurt(rng(1, 2));
}
if (!digging() && !has_flag(MF_FLIES) &&
g->m.tr_at(posx(), posy()) != tr_null) { // Monster stepped on a trap!
trap* tr = g->traps[g->m.tr_at(posx(), posy())];
if (dice(3, type->sk_dodge + 1) < dice(3, tr->avoidance)) {
trapfuncm f;
(f.*(tr->actm))(this, posx(), posy());
}
}
// Diggers turn the dirt into dirtmound
if (digging()) {
int factor = 0;
switch (type->size) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if (has_flag(MF_VERMIN)) {
factor *= 100;
}
if (one_in(factor)) {
g->m.ter_set(posx(), posy(), t_dirtmound);
}
}
// Acid trail monsters leave... a trail of acid
if (has_flag(MF_ACIDTRAIL)) {
g->m.add_field(posx(), posy(), fd_acid, 3);
}
if (has_flag(MF_SLUDGETRAIL)) {
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
const int fstr = 3 - (abs(dx) + abs(dy));
if (fstr >= 2) {
g->m.add_field(posx() + dx, posy() + dy, fd_sludge, fstr);
}
}
}
}
return 1;
}
void monster::plan(game *g)
{
int sightrange = g->light_level();
int closest = -1;
int dist = 1000;
int tc, stc;
bool fleeing = false;
if (friendly != 0) { // Target monsters, not the player!
for (int i = 0; i < g->z.size(); i++) {
monster *tmp = &(g->z[i]);
if (tmp->friendly == 0 && rl_dist(posx, posy, tmp->posx, tmp->posy) < dist &&
g->m.sees(posx, posy, tmp->posx, tmp->posy, sightrange, tc)) {
closest = i;
dist = rl_dist(posx, posy, tmp->posx, tmp->posy);
stc = tc;
}
}
if (has_effect(ME_DOCILE))
closest = -1;
if (closest >= 0)
set_dest(g->z[closest].posx, g->z[closest].posy, stc);
else if (friendly > 0 && one_in(3)) // Grow restless with no targets
friendly--;
else if (friendly < 0 && g->sees_u(posx, posy, tc)) {
if (rl_dist(posx, posy, g->u.posx, g->u.posy) > 2)
set_dest(g->u.posx, g->u.posy, tc);
else
plans.clear();
}
return;
}
if (is_fleeing(g->u) && can_see() && g->sees_u(posx, posy, tc)) {
fleeing = true;
wandx = posx * 2 - g->u.posx;
wandy = posy * 2 - g->u.posy;
wandf = 40;
dist = rl_dist(posx, posy, g->u.posx, g->u.posy);
}
// If we can see, and we can see a character, start moving towards them
if (!is_fleeing(g->u) && can_see() && g->sees_u(posx, posy, tc)) {
dist = rl_dist(posx, posy, g->u.posx, g->u.posy);
closest = -2;
stc = tc;
}
for (int i = 0; i < g->active_npc.size(); i++) {
npc *me = (g->active_npc[i]);
int medist = rl_dist(posx, posy, me->posx, me->posy);
if ((medist < dist || (!fleeing && is_fleeing(*me))) &&
(can_see() &&
g->m.sees(posx, posy, me->posx, me->posy, sightrange, tc))) {
if (is_fleeing(*me)) {
fleeing = true;
wandx = posx * 2 - me->posx;
wandy = posy * 2 - me->posy;
wandf = 40;
dist = medist;
} else if (can_see() &&
g->m.sees(posx, posy, me->posx, me->posy, sightrange, tc)) {
dist = rl_dist(posx, posy, me->posx, me->posy);
closest = i;
stc = tc;
}
}
}
if (!fleeing) {
fleeing = attitude() == MATT_FLEE;
for (int i = 0; i < g->z.size(); i++) {
monster *mon = &(g->z[i]);
int mondist = rl_dist(posx, posy, mon->posx, mon->posy);
if (mon->friendly != 0 && mondist < dist && can_see() &&
g->m.sees(posx, posy, mon->posx, mon->posy, sightrange, tc)) {
dist = mondist;
if (fleeing) {
wandx = posx * 2 - mon->posx;
wandy = posy * 2 - mon->posy;
wandf = 40;
} else {
closest = -3 - i;
stc = tc;
}
}
}
}
if (!fleeing) {
if (closest == -2)
set_dest(g->u.posx, g->u.posy, stc);
else if (closest <= -3)
set_dest(g->z[-3 - closest].posx, g->z[-3 - closest].posy, stc);
else if (closest >= 0)
set_dest(g->active_npc[closest]->posx, g->active_npc[closest]->posy, stc);
}
}
monster_attitude monster::attitude(player *u) const
{
if (friendly != 0 && !(has_effect("docile"))) {
return MATT_FRIEND;
}
if (friendly != 0 ) {
return MATT_FPASSIVE;
}
if (has_effect("run")) {
return MATT_FLEE;
}
if (has_effect("pacified")) {
return MATT_ZLAVE;
}
int effective_anger = anger;
int effective_morale = morale;
if (u != NULL) {
if (((type->in_species("MAMMAL") && u->has_trait("PHEROMONE_MAMMAL")) ||
(type->in_species("INSECT") && u->has_trait("PHEROMONE_INSECT"))) &&
effective_anger >= 10) {
effective_anger -= 20;
}
if ( (type->id == "mon_bee") && (u->has_trait("FLOWERS"))) {
effective_anger -= 10;
}
if (u->has_trait("TERRIFYING")) {
effective_morale -= 10;
}
if (u->has_trait("ANIMALEMPATH") && has_flag(MF_ANIMAL)) {
if (effective_anger >= 10) {
effective_anger -= 10;
}
if (effective_anger < 10) {
effective_morale += 5;
}
}
if (u->has_trait("ANIMALDISCORD") && has_flag(MF_ANIMAL)) {
if (effective_anger >= 10) {
effective_anger += 10;
}
if (effective_anger < 10) {
effective_morale -= 5;
}
}
}
if (effective_morale < 0) {
if (effective_morale + effective_anger > 0) {
return MATT_FOLLOW;
}
return MATT_FLEE;
}
if (effective_anger <= 0) {
return MATT_IGNORE;
}
if (effective_anger < 10) {
return MATT_FOLLOW;
}
return MATT_ATTACK;
}
// This must be called when any of the following change:
// - effects
// - bionics
// - traits
// - underwater
// - clothes
// With the exception of clothes, all changes to these character attributes must
// occur through a function in this class which calls this function. Clothes are
// typically added/removed with wear() and takeoff(), but direct access to the
// 'wears' vector is still allowed due to refactor exhaustion.
void Character::recalc_sight_limits()
{
sight_max = 9999;
vision_mode_cache.reset();
// Set sight_max.
if (has_effect("blind") || worn_with_flag("BLIND") || has_active_bionic("bio_blindfold")) {
sight_max = 0;
} else if( has_effect("boomered") && (!(has_trait("PER_SLIME_OK"))) ) {
sight_max = 1;
vision_mode_cache.set( BOOMERED );
} else if (has_effect("in_pit") ||
(underwater && !has_bionic("bio_membrane") &&
!has_trait("MEMBRANE") && !worn_with_flag("SWIM_GOGGLES") &&
!has_trait("CEPH_EYES") && !has_trait("PER_SLIME_OK") ) ) {
sight_max = 1;
} else if (has_active_mutation("SHELL2")) {
// You can kinda see out a bit.
sight_max = 2;
} else if ( (has_trait("MYOPIC") || has_trait("URSINE_EYE")) &&
!is_wearing("glasses_eye") && !is_wearing("glasses_monocle") &&
!is_wearing("glasses_bifocal") && !has_effect("contacts")) {
sight_max = 4;
} else if (has_trait("PER_SLIME")) {
sight_max = 6;
} else if( has_effect( "darkness" ) ) {
vision_mode_cache.set( DARKNESS );
sight_max = 10;
}
// Debug-only NV, by vache's request
if( has_trait("DEBUG_NIGHTVISION") ) {
vision_mode_cache.set( DEBUG_NIGHTVISION );
}
if( has_nv() ) {
vision_mode_cache.set( NV_GOGGLES );
}
if( has_active_mutation("NIGHTVISION3") || is_wearing("rm13_armor_on") ) {
vision_mode_cache.set( NIGHTVISION_3 );
}
if( has_active_mutation("ELFA_FNV") ) {
vision_mode_cache.set( FULL_ELFA_VISION );
}
if( has_active_mutation("CEPH_VISION") ) {
vision_mode_cache.set( CEPH_VISION );
}
if (has_active_mutation("ELFA_NV")) {
vision_mode_cache.set( ELFA_VISION );
}
if( has_active_mutation("NIGHTVISION2") ) {
vision_mode_cache.set( NIGHTVISION_2 );
}
if( has_active_mutation("FEL_NV") ) {
vision_mode_cache.set( FELINE_VISION );
}
if( has_active_mutation("URSINE_EYE") ) {
vision_mode_cache.set( URSINE_VISION );
}
if (has_active_mutation("NIGHTVISION")) {
vision_mode_cache.set(NIGHTVISION_1);
}
if( has_trait("BIRD_EYE") ) {
vision_mode_cache.set( BIRD_EYE);
}
}
void player::complete_craft()
{
const recipe *making = &recipe_dict[ activity.name ]; // Which recipe is it?
int batch_size = activity.values.front();
if( making == nullptr ) {
debugmsg( "no recipe with id %s found", activity.name.c_str() );
activity.set_to_null();
return;
}
int secondary_dice = 0;
int secondary_difficulty = 0;
for( const auto &pr : making->required_skills ) {
secondary_dice += get_skill_level( pr.first );
secondary_difficulty += pr.second;
}
// # of dice is 75% primary skill, 25% secondary (unless secondary is null)
int skill_dice;
if( secondary_difficulty > 0 ) {
skill_dice = get_skill_level( making->skill_used ) * 3 + secondary_dice;
} else {
skill_dice = get_skill_level( making->skill_used ) * 4;
}
auto helpers = g->u.get_crafting_helpers();
for( const npc *np : helpers ) {
if( np->get_skill_level( making->skill_used ) >=
get_skill_level( making->skill_used ) ) {
// NPC assistance is worth half a skill level
skill_dice += 2;
add_msg( m_info, _( "%s helps with crafting..." ), np->name.c_str() );
break;
}
}
// farsightedness can impose a penalty on electronics and tailoring success
// it's equivalent to a 2-rank electronics penalty, 1-rank tailoring
if( has_trait( trait_id( "HYPEROPIC" ) ) && !is_wearing( "glasses_reading" ) &&
!is_wearing( "glasses_bifocal" ) && !has_effect( effect_contacts ) ) {
int main_rank_penalty = 0;
if( making->skill_used == skill_id( "electronics" ) ) {
main_rank_penalty = 2;
} else if( making->skill_used == skill_id( "tailor" ) ) {
main_rank_penalty = 1;
}
skill_dice -= main_rank_penalty * 4;
}
// It's tough to craft with paws. Fortunately it's just a matter of grip and fine-motor,
// not inability to see what you're doing
if( has_trait( trait_PAWS ) || has_trait( trait_PAWS_LARGE ) ) {
int paws_rank_penalty = 0;
if( has_trait( trait_PAWS_LARGE ) ) {
paws_rank_penalty += 1;
}
if( making->skill_used == skill_id( "electronics" )
|| making->skill_used == skill_id( "tailor" )
|| making->skill_used == skill_id( "mechanics" ) ) {
paws_rank_penalty += 1;
}
skill_dice -= paws_rank_penalty * 4;
}
// Sides on dice is 16 plus your current intelligence
///\EFFECT_INT increases crafting success chance
int skill_sides = 16 + int_cur;
int diff_dice;
if( secondary_difficulty > 0 ) {
diff_dice = making->difficulty * 3 + secondary_difficulty;
} else {
// Since skill level is * 4 also
diff_dice = making->difficulty * 4;
}
int diff_sides = 24; // 16 + 8 (default intelligence)
int skill_roll = dice( skill_dice, skill_sides );
int diff_roll = dice( diff_dice, diff_sides );
if( making->skill_used ) {
const double batch_mult = 1 + time_to_craft( *making, batch_size ) / 30000.0;
//normalize experience gain to crafting time, giving a bonus for longer crafting
practice( making->skill_used, ( int )( ( making->difficulty * 15 + 10 ) * batch_mult ),
( int )making->difficulty * 1.25 );
//NPCs assisting or watching should gain experience...
for( auto &elem : helpers ) {
//If the NPC can understand what you are doing, they gain more exp
if( elem->get_skill_level( making->skill_used ) >= making->difficulty ) {
elem->practice( making->skill_used,
( int )( ( making->difficulty * 15 + 10 ) * batch_mult *
.50 ), ( int )making->difficulty * 1.25 );
if( batch_size > 1 ) {
add_msg( m_info, _( "%s assists with crafting..." ), elem->name.c_str() );
}
if( batch_size == 1 ) {
add_msg( m_info, _( "%s could assist you with a batch..." ), elem->name.c_str() );
}
//NPCs around you understand the skill used better
} else {
elem->practice( making->skill_used,
( int )( ( making->difficulty * 15 + 10 ) * batch_mult * .15 ),
( int )making->difficulty * 1.25 );
add_msg( m_info, _( "%s watches you craft..." ), elem->name.c_str() );
}
}
}
// Messed up badly; waste some components.
if( making->difficulty != 0 && diff_roll > skill_roll * ( 1 + 0.1 * rng( 1, 5 ) ) ) {
add_msg( m_bad, _( "You fail to make the %s, and waste some materials." ),
item::nname( making->result ).c_str() );
if( last_craft->has_cached_selections() ) {
last_craft->consume_components();
} else {
// @todo Guarantee that selections are cached
const auto &req = making->requirements();
for( const auto &it : req.get_components() ) {
consume_items( it, batch_size );
}
for( const auto &it : req.get_tools() ) {
consume_tools( it, batch_size );
}
}
activity.set_to_null();
return;
// Messed up slightly; no components wasted.
} else if( diff_roll > skill_roll ) {
add_msg( m_neutral, _( "You fail to make the %s, but don't waste any materials." ),
item::nname( making->result ).c_str() );
//this method would only have been called from a place that nulls activity.type,
//so it appears that it's safe to NOT null that variable here.
//rationale: this allows certain contexts (e.g. ACT_LONGCRAFT) to distinguish major and minor failures
return;
}
// If we're here, the craft was a success!
// Use up the components and tools
std::list<item> used;
if( !last_craft->has_cached_selections() ) {
// This should fail and return, but currently crafting_command isn't saved
// Meaning there are still cases where has_cached_selections will be false
// @todo Allow saving last_craft and debugmsg+fail craft if selection isn't cached
if( !has_trait( trait_id( "DEBUG_HS" ) ) ) {
const auto &req = making->requirements();
for( const auto &it : req.get_components() ) {
std::list<item> tmp = consume_items( it, batch_size );
used.splice( used.end(), tmp );
}
for( const auto &it : req.get_tools() ) {
consume_tools( it, batch_size );
}
}
} else if( !has_trait( trait_id( "DEBUG_HS" ) ) ) {
used = last_craft->consume_components();
if( used.empty() ) {
return;
}
}
// Set up the new item, and assign an inventory letter if available
std::vector<item> newits = making->create_results( batch_size );
bool first = true;
float used_age_tally = 0;
int used_age_count = 0;
size_t newit_counter = 0;
for( item &newit : newits ) {
// messages, learning of recipe, food spoilage calc only once
if( first ) {
first = false;
if( knows_recipe( making ) ) {
add_msg( _( "You craft %s from memory." ), newit.type_name( 1 ).c_str() );
} else {
add_msg( _( "You craft %s using a book as a reference." ), newit.type_name( 1 ).c_str() );
// If we made it, but we don't know it,
// we're making it from a book and have a chance to learn it.
// Base expected time to learn is 1000*(difficulty^4)/skill/int moves.
// This means time to learn is greatly decreased with higher skill level,
// but also keeps going up as difficulty goes up.
// Worst case is lvl 10, which will typically take
// 10^4/10 (1,000) minutes, or about 16 hours of crafting it to learn.
int difficulty = has_recipe( making, crafting_inventory(), helpers );
///\EFFECT_INT increases chance to learn recipe when crafting from a book
if( x_in_y( making->time, ( 1000 * 8 *
( difficulty * difficulty * difficulty * difficulty ) ) /
( std::max( get_skill_level( making->skill_used ).level(), 1 ) * std::max( get_int(), 1 ) ) ) ) {
learn_recipe( ( recipe * )making );
add_msg( m_good, _( "You memorized the recipe for %s!" ),
newit.type_name( 1 ).c_str() );
}
}
for( auto &elem : used ) {
if( elem.goes_bad() ) {
used_age_tally += elem.get_relative_rot();
++used_age_count;
}
}
}
// Don't store components for things made by charges,
// don't store components for things that can't be uncrafted.
if( recipe_dictionary::get_uncraft( making->result ) && !newit.count_by_charges() ) {
// Setting this for items counted by charges gives only problems:
// those items are automatically merged everywhere (map/vehicle/inventory),
// which would either loose this information or merge it somehow.
set_components( newit.components, used, batch_size, newit_counter );
newit_counter++;
}
finalize_crafted_item( newit, used_age_tally, used_age_count );
set_item_inventory( newit );
}
if( making->has_byproducts() ) {
std::vector<item> bps = making->create_byproducts( batch_size );
for( auto &bp : bps ) {
finalize_crafted_item( bp, used_age_tally, used_age_count );
set_item_inventory( bp );
}
}
inv.restack( this );
}
bool Character::move_effects(bool attacking)
{
if (has_effect("downed")) {
if (rng(0, 40) > get_dex() + int(get_str() / 2)) {
add_msg_if_player(_("You struggle to stand."));
} else {
add_msg_player_or_npc(m_good, _("You stand up."),
_("<npcname> stands up."));
remove_effect("downed");
}
return false;
}
if (has_effect("webbed")) {
if (x_in_y(get_str(), 6 * get_effect_int("webbed"))) {
add_msg_player_or_npc(m_good, _("You free yourself from the webs!"),
_("<npcname> frees themselves from the webs!"));
remove_effect("webbed");
} else {
add_msg_if_player(_("You try to free yourself from the webs, but can't get loose!"));
}
return false;
}
if (has_effect("lightsnare")) {
if(x_in_y(get_str(), 12) || x_in_y(get_dex(), 8)) {
remove_effect("lightsnare");
add_msg_player_or_npc(m_good, _("You free yourself from the light snare!"),
_("<npcname> frees themselves from the light snare!"));
item string("string_36", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), string);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the light snare, but can't get loose!"));
}
return false;
}
if (has_effect("heavysnare")) {
if(x_in_y(get_str(), 32) || x_in_y(get_dex(), 16)) {
remove_effect("heavysnare");
add_msg_player_or_npc(m_good, _("You free yourself from the heavy snare!"),
_("<npcname> frees themselves from the heavy snare!"));
item rope("rope_6", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), rope);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the heavy snare, but can't get loose!"));
}
return false;
}
if (has_effect("beartrap")) {
/* Real bear traps can't be removed without the proper tools or immense strength; eventually this should
allow normal players two options: removal of the limb or removal of the trap from the ground
(at which point the player could later remove it from the leg with the right tools).
As such we are currently making it a bit easier for players and NPC's to get out of bear traps.
*/
if(x_in_y(get_str(), 100)) {
remove_effect("beartrap");
add_msg_player_or_npc(m_good, _("You free yourself from the bear trap!"),
_("<npcname> frees themselves from the bear trap!"));
item beartrap("beartrap", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), beartrap);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the bear trap, but can't get loose!"));
}
return false;
}
if (has_effect("crushed")) {
// Strength helps in getting free, but dex also helps you worm your way out of the rubble
if(x_in_y(get_str() + get_dex() / 4, 100)) {
remove_effect("crushed");
add_msg_player_or_npc(m_good, _("You free yourself from the rubble!"),
_("<npcname> frees themselves from the rubble!"));
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the rubble, but can't get loose!"));
}
return false;
}
// Below this point are things that allow for movement if they succeed
// Currently we only have one thing that forces movement if you succeed, should we get more
// than this will need to be reworked to only have success effects if /all/ checks succeed
if (has_effect("in_pit")) {
if (rng(0, 40) > get_str() + int(get_dex() / 2)) {
add_msg_if_player(m_bad, _("You try to escape the pit, but slip back in."));
return false;
} else {
add_msg_player_or_npc(m_good, _("You escape the pit!"),
_("<npcname> escapes the pit!"));
remove_effect("in_pit");
}
}
if (has_effect("grabbed")){
int zed_number = 0;
for( auto &&dest : g->m.points_in_radius( pos(), 1, 0 ) ){
if (g->mon_at(dest) != -1){
zed_number ++;
}
}
if (attacking == true || zed_number == 0){
return true;
}
if (get_dex() > get_str() ? rng(0, get_dex()) : rng( 0, get_str()) < rng( get_effect_int("grabbed") , 8) ){
add_msg_player_or_npc(m_bad, _("You try break out of the grab, but fail!"),
_("<npcname> tries to break out of the grab, but fails!"));
return false;
} else {
add_msg_player_or_npc(m_good, _("You break out of the grab!"),
_("<npcname> breaks out of the grab!"));
remove_effect("grabbed");
}
}
return Creature::move_effects(attacking);
}
int monster::move_to(int x, int y, bool force)
{
// Make sure that we can move there, unless force is true.
if(!force) if(!g->is_empty(x, y) || !can_move_to(x, y)) {
return 0;
}
if (!plans.empty()) {
plans.erase(plans.begin());
}
if (!force) {
moves -= calc_movecost(posx(), posy(), x, y);
}
//Check for moving into/out of water
bool was_water = g->m.is_divable(posx(), posy());
bool will_be_water = !has_flag( MF_FLIES ) && can_submerge() && g->m.is_divable(x, y);
if(was_water && !will_be_water && g->u.sees(x, y)) {
//Use more dramatic messages for swimming monsters
add_msg(m_warning, _("A %s %s from the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("leaps") : _("emerges"),
g->m.tername(posx(), posy()).c_str());
} else if(!was_water && will_be_water && g->u.sees(x, y)) {
add_msg(m_warning, _("A %s %s into the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("dives") : _("sinks"),
g->m.tername(x, y).c_str());
}
setpos(x, y);
footsteps(x, y);
underwater = will_be_water;
if(is_hallucination()) {
//Hallucinations don't do any of the stuff after this point
return 1;
}
if (type->size != MS_TINY && g->m.has_flag("SHARP", posx(), posy()) && !one_in(4)) {
apply_damage( nullptr, bp_torso, rng( 2, 3 ) );
}
if (type->size != MS_TINY && g->m.has_flag("ROUGH", posx(), posy()) && one_in(6)) {
apply_damage( nullptr, bp_torso, rng( 1, 2 ) );
}
if (g->m.has_flag("UNSTABLE", x, y)) {
add_effect("bouldering", 1, num_bp, true);
} else if (has_effect("bouldering")) {
remove_effect("bouldering");
}
if (!digging() && !has_flag(MF_FLIES) &&
g->m.tr_at(posx(), posy()) != tr_null) { // Monster stepped on a trap!
trap* tr = traplist[g->m.tr_at(posx(), posy())];
if (dice(3, type->sk_dodge + 1) < dice(3, tr->get_avoidance())) {
tr->trigger(this, posx(), posy());
}
}
if( !will_be_water && ( has_flag(MF_DIGS) || has_flag(MF_CAN_DIG) ) ) {
underwater = g->m.has_flag("DIGGABLE", posx(), posy() );
}
// Diggers turn the dirt into dirtmound
if (digging()){
int factor = 0;
switch (type->size) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if (has_flag(MF_VERMIN)) {
factor *= 100;
}
if (one_in(factor)) {
g->m.ter_set(posx(), posy(), t_dirtmound);
}
}
// Acid trail monsters leave... a trail of acid
if (has_flag(MF_ACIDTRAIL)){
g->m.add_field(posx(), posy(), fd_acid, 3);
}
if (has_flag(MF_SLUDGETRAIL)) {
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
const int fstr = 3 - (abs(dx) + abs(dy));
if (fstr >= 2) {
g->m.add_field(posx() + dx, posy() + dy, fd_sludge, fstr);
}
}
}
}
if (has_flag(MF_LEAKSGAS)){
if (one_in(6)){
g->m.add_field(posx() + rng(-1,1), posy() + rng(-1, 1), fd_toxic_gas, 3);
}
}
return 1;
}
void monster::plan(const mfactions &factions)
{
// Bots are more intelligent than most living stuff
bool electronic = has_flag( MF_ELECTRONIC );
Creature *target = nullptr;
// 8.6f is rating for tank drone 60 tiles away, moose 16 or boomer 33
float dist = !electronic ? 1000 : 8.6f;
int bresenham_slope = 0;
int selected_slope = 0;
bool fleeing = false;
bool docile = has_flag( MF_VERMIN ) || ( friendly != 0 && has_effect( "docile" ) );
bool angers_hostile_weak = type->anger.find( MTRIG_HOSTILE_WEAK ) != type->anger.end();
int angers_hostile_near = ( type->anger.find( MTRIG_HOSTILE_CLOSE ) != type->anger.end() ) ? 5 : 0;
int fears_hostile_near = ( type->fear.find( MTRIG_HOSTILE_CLOSE ) != type->fear.end() ) ? 5 : 0;
bool group_morale = has_flag( MF_GROUP_MORALE ) && morale < type->morale;
bool swarms = has_flag( MF_SWARMS );
auto mood = attitude();
// If we can see the player, move toward them or flee.
if( friendly == 0 && sees( g->u, bresenham_slope ) ) {
dist = rate_target( g->u, bresenham_slope, dist, electronic );
fleeing = fleeing || is_fleeing( g->u );
target = &g->u;
selected_slope = bresenham_slope;
if( dist <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
} else if( friendly != 0 && !docile ) {
// Target unfriendly monsters, only if we aren't interacting with the player.
for( int i = 0, numz = g->num_zombies(); i < numz; i++ ) {
monster &tmp = g->zombie( i );
if( tmp.friendly == 0 ) {
float rating = rate_target( tmp, bresenham_slope, dist, electronic );
if( rating < dist ) {
target = &tmp;
dist = rating;
selected_slope = bresenham_slope;
}
}
}
}
if( !docile ) {
for( size_t i = 0; i < g->active_npc.size(); i++ ) {
npc *me = g->active_npc[i];
float rating = rate_target( *me, bresenham_slope, dist, electronic );
bool fleeing_from = is_fleeing( *me );
// Switch targets if closer and hostile or scarier than current target
if( ( rating < dist && fleeing ) ||
( rating < dist && attitude( me ) == MATT_ATTACK ) ||
( !fleeing && fleeing_from ) ) {
target = me;
dist = rating;
selected_slope = bresenham_slope;
}
fleeing = fleeing || fleeing_from;
if( rating <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
}
}
fleeing = fleeing || ( mood == MATT_FLEE );
if( friendly == 0 && !docile ) {
for( const auto &fac : factions ) {
auto faction_att = faction->attitude( fac.first );
if( faction_att == MFA_NEUTRAL || faction_att == MFA_FRIENDLY ) {
continue;
}
for( int i : fac.second ) { // mon indices
monster &mon = g->zombie( i );
float rating = rate_target( mon, bresenham_slope, dist, electronic );
if( rating < dist ) {
target = &mon;
dist = rating;
selected_slope = bresenham_slope;
}
if( rating <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
}
}
}
// Friendly monsters here
// Avoid for hordes of same-faction stuff or it could get expensive
const monfaction *actual_faction = friendly == 0 ? faction : GetMFact( "player" );
auto const &myfaction_iter = factions.find( actual_faction );
if( myfaction_iter == factions.end() ) {
DebugLog( D_ERROR, D_GAME ) << disp_name() << " tried to find faction " <<
( friendly == 0 ? faction->name : "player" ) << " which wasn't loaded in game::monmove";
swarms = false;
group_morale = false;
}
swarms = swarms && target == nullptr; // Only swarm if we have no target
if( group_morale || swarms ) {
auto const &myfaction = myfaction_iter->second;
for( int i : myfaction ) {
monster &mon = g->zombie( i );
float rating = rate_target( mon, bresenham_slope, dist, electronic );
if( group_morale && rating <= 10 ) {
morale += 10 - rating;
}
if( swarms ) {
if( rating < 5 ) { // Too crowded here
wandx = posx() * rng( 1, 3 ) - mon.posx();
wandy = posy() * rng( 1, 3 ) - mon.posy();
wandf = 2;
target = nullptr;
// Swarm to the furthest ally you can see
} else if( rating < INT_MAX && rating > dist && wandf <= 0 ) {
target = &mon;
dist = rating;
selected_slope = bresenham_slope;
}
}
}
}
if( target != nullptr ) {
if( one_in( 2 ) ) { // Random for the diversity of the trajectory
++selected_slope;
} else {
--selected_slope;
}
point dest = target->pos();
auto att_to_target = attitude_to( *target );
if( att_to_target == Attitude::A_HOSTILE && !fleeing ) {
set_dest( dest.x, dest.y, selected_slope );
} else if( fleeing ) {
set_dest( posx() * 2 - dest.x, posy() * 2 - dest.y, selected_slope );
}
if( angers_hostile_weak && att_to_target != Attitude::A_FRIENDLY ) {
int hp_per = target->hp_percentage();
if( hp_per <= 70 ) {
anger += 10 - int( hp_per / 10 );
}
}
} else if( friendly > 0 && one_in(3)) {
// Grow restless with no targets
friendly--;
} else if( friendly < 0 && sees( g->u, bresenham_slope ) ) {
if( rl_dist( pos(), g->u.pos() ) > 2 ) {
set_dest(g->u.posx(), g->u.posy(), bresenham_slope);
} else {
plans.clear();
}
}
// If we're not adjacent to the start of our plan path, don't act on it.
// This is to catch when we had pre-existing invalid plans and
// made it through the function without changing them.
if( !plans.empty() && square_dist(pos().x, pos().y,
plans.front().x, plans.front().y ) > 1 ) {
plans.clear();
}
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move()
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0) {
wandf--;
}
//Hallucinations have a chance of disappearing each turn
if (is_hallucination() && one_in(25)) {
die( nullptr );
return;
}
//The monster can consume objects it stands on. Check if there are any.
//If there are. Consume them.
if( !is_hallucination() && has_flag( MF_ABSORBS ) ) {
if(!g->m.i_at(posx(), posy()).empty()) {
add_msg(_("The %s flows around the objects on the floor and they are quickly dissolved!"),
name().c_str());
for( auto &elem : g->m.i_at(posx(), posy()) ) {
hp += elem.volume(); // Yeah this means it can get more HP than normal.
}
g->m.i_clear(posx(), posy());
}
}
// First, use the special attack, if we can!
for (size_t i = 0; i < sp_timeout.size(); ++i) {
if (sp_timeout[i] > 0) {
sp_timeout[i]--;
}
if( sp_timeout[i] == 0 && !has_effect("pacified") && !is_hallucination() ) {
type->sp_attack[i](this, i);
}
}
if (moves < 0) {
return;
}
if (!move_effects()) {
moves = 0;
return;
}
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect("stunned")) {
stumble(false);
moves = 0;
return;
}
if (friendly != 0) {
if (friendly > 0) {
friendly--;
}
friendly_move();
return;
}
bool moved = false;
point next;
// Set attitude to attitude to our current target
monster_attitude current_attitude = attitude( nullptr );
if( !plans.empty() ) {
if (plans.back().x == g->u.posx() && plans.back().y == g->u.posy()) {
current_attitude = attitude( &(g->u) );
} else {
for( auto &i : g->active_npc ) {
if( plans.back().x == i->posx() && plans.back().y == i->posy() ) {
current_attitude = attitude( i );
}
}
}
}
if( current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST) ) {
moves -= 100;
stumble(false);
return;
}
int mondex = !plans.empty() ? g->mon_at( plans[0].x, plans[0].y ) : -1;
auto mon_att = mondex != -1 ? attitude_to( g->zombie( mondex ) ) : A_HOSTILE;
if( !plans.empty() &&
( mon_att == A_HOSTILE || has_flag(MF_ATTACKMON) ) &&
( can_move_to( plans[0].x, plans[0].y ) ||
( plans[0].x == g->u.posx() && plans[0].y == g->u.posy() ) ||
( ( has_flag( MF_BASHES ) || has_flag( MF_BORES ) ) &&
g->m.bash_rating( bash_estimate(), plans[0].x, plans[0].y) >= 0 ) ) ) {
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
plans.clear();
point tmp = scent_move();
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
plans.clear();
point tmp = wander_next();
if (tmp.x != posx() || tmp.y != posy()) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
// Note: The below works because C++ in A() || B() won't call B() if A() is true
int& x = next.x; int& y = next.y; // Define alias for x and y
bool did_something = attack_at(x, y) || bash_at(x, y) || move_to(x, y);
if(!did_something) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
}
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.empty())) ||
!moved) {
stumble(moved);
}
}
bool Character::move_effects(bool attacking)
{
if (has_effect("downed")) {
///\EFFECT_DEX increases chance to stand up when knocked down
///\EFFECT_STR increases chance to stand up when knocked down, slightly
if (rng(0, 40) > get_dex() + get_str() / 2) {
add_msg_if_player(_("You struggle to stand."));
} else {
add_msg_player_or_npc(m_good, _("You stand up."),
_("<npcname> stands up."));
remove_effect("downed");
}
return false;
}
if (has_effect("webbed")) {
///\EFFECT_STR increases chance to escape webs
if (x_in_y(get_str(), 6 * get_effect_int("webbed"))) {
add_msg_player_or_npc(m_good, _("You free yourself from the webs!"),
_("<npcname> frees themselves from the webs!"));
remove_effect("webbed");
} else {
add_msg_if_player(_("You try to free yourself from the webs, but can't get loose!"));
}
return false;
}
if (has_effect("lightsnare")) {
///\EFFECT_STR increases chance to escape light snare
///\EFFECT_DEX increases chance to escape light snare
if(x_in_y(get_str(), 12) || x_in_y(get_dex(), 8)) {
remove_effect("lightsnare");
add_msg_player_or_npc(m_good, _("You free yourself from the light snare!"),
_("<npcname> frees themselves from the light snare!"));
item string("string_36", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), string);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the light snare, but can't get loose!"));
}
return false;
}
if (has_effect("heavysnare")) {
///\EFFECT_STR increases chance to escape heavy snare, slightly
///\EFFECT_DEX increases chance to escape light snare
if(x_in_y(get_str(), 32) || x_in_y(get_dex(), 16)) {
remove_effect("heavysnare");
add_msg_player_or_npc(m_good, _("You free yourself from the heavy snare!"),
_("<npcname> frees themselves from the heavy snare!"));
item rope("rope_6", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), rope);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the heavy snare, but can't get loose!"));
}
return false;
}
if (has_effect("beartrap")) {
/* Real bear traps can't be removed without the proper tools or immense strength; eventually this should
allow normal players two options: removal of the limb or removal of the trap from the ground
(at which point the player could later remove it from the leg with the right tools).
As such we are currently making it a bit easier for players and NPC's to get out of bear traps.
*/
///\EFFECT_STR increases chance to escape bear trap
if(x_in_y(get_str(), 100)) {
remove_effect("beartrap");
add_msg_player_or_npc(m_good, _("You free yourself from the bear trap!"),
_("<npcname> frees themselves from the bear trap!"));
item beartrap("beartrap", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), beartrap);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the bear trap, but can't get loose!"));
}
return false;
}
if (has_effect("crushed")) {
///\EFFECT_STR increases chance to escape crushing rubble
///\EFFECT_DEX increases chance to escape crushing rubble, slightly
if(x_in_y(get_str() + get_dex() / 4, 100)) {
remove_effect("crushed");
add_msg_player_or_npc(m_good, _("You free yourself from the rubble!"),
_("<npcname> frees themselves from the rubble!"));
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the rubble, but can't get loose!"));
}
return false;
}
// Below this point are things that allow for movement if they succeed
// Currently we only have one thing that forces movement if you succeed, should we get more
// than this will need to be reworked to only have success effects if /all/ checks succeed
if (has_effect("in_pit")) {
///\EFFECT_STR increases chance to escape pit
///\EFFECT_DEX increases chance to escape pit, slightly
if (rng(0, 40) > get_str() + get_dex() / 2) {
add_msg_if_player(m_bad, _("You try to escape the pit, but slip back in."));
return false;
} else {
add_msg_player_or_npc(m_good, _("You escape the pit!"),
_("<npcname> escapes the pit!"));
remove_effect("in_pit");
}
}
if( has_effect( "grabbed" ) && !attacking ) {
int zed_number = 0;
for( auto &&dest : g->m.points_in_radius( pos(), 1, 0 ) ){
if( g->mon_at( dest ) != -1 &&
( g->zombie( g->mon_at( dest ) ).has_flag( MF_GRABS ) ||
g->zombie( g->mon_at( dest ) ).type->has_special_attack( "GRAB" ) ) ) {
zed_number ++;
}
}
if( zed_number == 0 ) {
add_msg_player_or_npc( m_good, _( "You find yourself no longer grabbed." ),
_( "<npcname> finds themselves no longer grabbed." ) );
remove_effect( "grabbed" );
///\EFFECT_DEX increases chance to escape grab, if >STR
///\EFFECT_STR increases chance to escape grab, if >DEX
} else if( rng( 0, std::max( get_dex(), get_str() ) ) < rng( get_effect_int( "grabbed" ), 8 ) ) {
// Randomly compare higher of dex or str to grab intensity.
add_msg_player_or_npc( m_bad, _( "You try break out of the grab, but fail!" ),
_( "<npcname> tries to break out of the grab, but fails!" ) );
return false;
} else {
add_msg_player_or_npc( m_good, _( "You break out of the grab!" ),
_( "<npcname> breaks out of the grab!" ) );
remove_effect( "grabbed" );
}
}
return Creature::move_effects( attacking );
}
bool Creature::in_sleep_state() const
{
return has_effect("sleep") || has_effect("lying_down");
}
bool Creature::in_sleep_state() const
{
return has_effect( effect_sleep ) || has_effect( effect_lying_down );
}
void Creature::add_effect( efftype_id eff_id, int dur, body_part bp,
bool permanent, int intensity, bool force )
{
// Check our innate immunity
if( !force && is_immune_effect( eff_id ) ) {
return;
}
// Mutate to a main (HP'd) body_part if necessary.
if (effect_types[eff_id].get_main_parts()) {
bp = mutate_to_main_part(bp);
}
bool found = false;
// Check if we already have it
auto matching_map = effects.find(eff_id);
if (matching_map != effects.end()) {
auto found_effect = effects[eff_id].find(bp);
if (found_effect != effects[eff_id].end()) {
found = true;
effect &e = found_effect->second;
// If we do, mod the duration, factoring in the mod value
e.mod_duration(dur * e.get_dur_add_perc() / 100);
// Limit to max duration
if (e.get_max_duration() > 0 && e.get_duration() > e.get_max_duration()) {
e.set_duration(e.get_max_duration());
}
// Adding a permanent effect makes it permanent
if( e.is_permanent() ) {
e.pause_effect();
}
// Set intensity if value is given
if (intensity > 0) {
e.set_intensity(intensity);
// Else intensity uses the type'd step size if it already exists
} else if (e.get_int_add_val() != 0) {
e.mod_intensity(e.get_int_add_val());
}
// Bound intensity by [1, max intensity]
if (e.get_intensity() < 1) {
add_msg( m_debug, "Bad intensity, ID: %s", e.get_id().c_str() );
e.set_intensity(1);
} else if (e.get_intensity() > e.get_max_intensity()) {
e.set_intensity(e.get_max_intensity());
}
}
}
if( found == false ) {
// If we don't already have it then add a new one
// First make sure it's a valid effect
if (effect_types.find(eff_id) == effect_types.end()) {
return;
}
// Then check if the effect is blocked by another
for( auto &elem : effects ) {
for( auto &_effect_it : elem.second ) {
for( const auto blocked_effect : _effect_it.second.get_blocks_effects() ) {
if (blocked_effect == eff_id) {
// The effect is blocked by another, return
return;
}
}
}
}
// Now we can make the new effect for application
effect new_eff(&effect_types[eff_id], dur, bp, permanent, intensity);
effect &e = new_eff;
// Bound to max duration
if (e.get_max_duration() > 0 && e.get_duration() > e.get_max_duration()) {
e.set_duration(e.get_max_duration());
}
// Bound new effect intensity by [1, max intensity]
if (new_eff.get_intensity() < 1) {
add_msg( m_debug, "Bad intensity, ID: %s", new_eff.get_id().c_str() );
new_eff.set_intensity(1);
} else if (new_eff.get_intensity() > new_eff.get_max_intensity()) {
new_eff.set_intensity(new_eff.get_max_intensity());
}
effects[eff_id][bp] = new_eff;
if (is_player()) {
// Only print the message if we didn't already have it
if(effect_types[eff_id].get_apply_message() != "") {
add_msg(effect_types[eff_id].gain_game_message_type(),
_(effect_types[eff_id].get_apply_message().c_str()));
}
add_memorial_log(pgettext("memorial_male",
effect_types[eff_id].get_apply_memorial_log().c_str()),
pgettext("memorial_female",
effect_types[eff_id].get_apply_memorial_log().c_str()));
}
// Perform any effect addition effects.
bool reduced = has_effect(e.get_resist_effect()) || has_trait(e.get_resist_trait());
add_eff_effects(e, reduced);
}
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move(game *g)
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0)
wandf--;
// First, use the special attack, if we can!
if (sp_timeout > 0)
sp_timeout--;
if (sp_timeout == 0 && (friendly == 0 || has_flag(MF_FRIENDLY_SPECIAL))) {
mattack ma;
(ma.*type->sp_attack)(g, this);
}
if (moves < 0)
return;
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect(ME_STUNNED)) {
stumble(g, false);
moves = 0;
return;
}
if (has_effect(ME_DOWNED)) {
moves = 0;
return;
}
if (has_effect(ME_BOULDERING)){
moves -= 20;
if (moves < 0)
moves = 0;
return;
}
if (friendly != 0) {
if (friendly > 0)
friendly--;
friendly_move(g);
return;
}
bool moved = false;
point next;
int mondex = (plans.size() > 0 ? g->mon_at(plans[0].x, plans[0].y) : -1);
monster_attitude current_attitude = attitude();
if (friendly == 0)
current_attitude = attitude(&(g->u));
// If our plans end in a player, set our attitude to consider that player
if (plans.size() > 0) {
if (plans.back().x == g->u.posx && plans.back().y == g->u.posy)
current_attitude = attitude(&(g->u));
else {
for (int i = 0; i < g->active_npc.size(); i++) {
if (plans.back().x == g->active_npc[i]->posx &&
plans.back().y == g->active_npc[i]->posy)
current_attitude = attitude((g->active_npc[i]));
}
}
}
if (current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST)) {
moves -= 100;
stumble(g, false);
return;
}
if (plans.size() > 0 && !is_fleeing(g->u) &&
(mondex == -1 || g->z[mondex].friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(g, plans[0].x, plans[0].y) ||
(plans[0].x == g->u.posx && plans[0].y == g->u.posy) ||
(g->m.has_flag(bashable, plans[0].x, plans[0].y) && has_flag(MF_BASHES)))){
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
point tmp = scent_move(g);
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
point tmp = sound_move(g);
if (tmp.x != posx || tmp.y != posy) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
mondex = g->mon_at(next.x, next.y);
int npcdex = g->npc_at(next.x, next.y);
if (next.x == g->u.posx && next.y == g->u.posy && type->melee_dice > 0)
hit_player(g, g->u);
else if (mondex != -1 && g->z[mondex].type->species == species_hallu) {
g->kill_mon(mondex);
moves -= 100;
} else if (mondex != -1 && type->melee_dice > 0 && this != &(g->z[mondex]) &&
(g->z[mondex].friendly != 0 || has_flag(MF_ATTACKMON)))
hit_monster(g, mondex);
else if (npcdex != -1 && type->melee_dice > 0)
hit_player(g, *g->active_npc[npcdex]);
else if ((!can_move_to(g, next.x, next.y) || one_in(3)) &&
g->m.has_flag(bashable, next.x, next.y) && has_flag(MF_BASHES)) {
std::string bashsound = "NOBASH"; // If we hear "NOBASH" it's time to debug!
int bashskill = int(type->melee_dice * type->melee_sides);
g->m.bash(next.x, next.y, bashskill, bashsound);
g->sound(next.x, next.y, 18, bashsound);
moves -= 100;
} else if (g->m.move_cost(next.x, next.y) == 0 && has_flag(MF_DESTROYS)) {
g->m.destroy(g, next.x, next.y, true);
moves -= 250;
} else if (can_move_to(g, next.x, next.y) && g->is_empty(next.x, next.y))
move_to(g, next.x, next.y);
else
moves -= 100;
} else
moves -= 100;
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.size() == 0)) ||
!moved)
stumble(g, moved);
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move(game *g)
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0)
wandf--;
//Hallucinations have a chance of disappearing each turn
if (is_hallucination() && one_in(25)) {
die(g);
return;
}
// First, use the special attack, if we can!
if (sp_timeout > 0) {
sp_timeout--;
}
if (sp_timeout == 0 && (friendly == 0 || has_flag(MF_FRIENDLY_SPECIAL))) {
mattack ma;
if(!is_hallucination()) {
(ma.*type->sp_attack)(g, this);
}
}
if (moves < 0)
return;
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect(ME_STUNNED)) {
stumble(g, false);
moves = 0;
return;
}
if (has_effect(ME_DOWNED)) {
moves = 0;
return;
}
if (has_effect(ME_BOULDERING)){
moves -= 20;
if (moves < 0) {
return;
}
}
if (friendly != 0) {
if (friendly > 0)
friendly--;
friendly_move(g);
return;
}
bool moved = false;
point next;
int mondex = (plans.size() > 0 ? g->mon_at(plans[0].x, plans[0].y) : -1);
monster_attitude current_attitude = attitude();
if (friendly == 0)
current_attitude = attitude(&(g->u));
// If our plans end in a player, set our attitude to consider that player
if (plans.size() > 0) {
if (plans.back().x == g->u.posx && plans.back().y == g->u.posy)
current_attitude = attitude(&(g->u));
else {
for (int i = 0; i < g->active_npc.size(); i++) {
if (plans.back().x == g->active_npc[i]->posx &&
plans.back().y == g->active_npc[i]->posy)
current_attitude = attitude((g->active_npc[i]));
}
}
}
if (current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST)) {
moves -= 100;
stumble(g, false);
return;
}
if (plans.size() > 0 && !is_fleeing(g->u) &&
(mondex == -1 || g->zombie(mondex).friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(g, plans[0].x, plans[0].y) ||
(plans[0].x == g->u.posx && plans[0].y == g->u.posy) ||
(g->m.has_flag(bashable, plans[0].x, plans[0].y) && has_flag(MF_BASHES)))){
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
plans.clear();
point tmp = scent_move(g);
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
plans.clear();
point tmp = wander_next(g);
if (tmp.x != posx() || tmp.y != posy()) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
// Note: The below works because C++ in A() || B() won't call B() if A() is true
int& x = next.x; int& y = next.y; // Define alias for x and y
bool did_something = attack_at(x, y) || bash_at(x, y) || move_to(g, x, y);
if(!did_something) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
}
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.size() == 0)) ||
!moved)
stumble(g, moved);
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move()
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0) {
wandf--;
}
//Hallucinations have a chance of disappearing each turn
if (is_hallucination() && one_in(25)) {
die();
return;
}
// First, use the special attack, if we can!
if (sp_timeout > 0) {
sp_timeout--;
}
//If this monster has the ability to heal in combat, do it now.
if (has_flag(MF_REGENERATES_50)) {
if (hp < type->hp) {
if (one_in(2)) {
g->add_msg(_("The %s is visibly regenerating!"), name().c_str());
}
hp += 50;
if(hp > type->hp) {
hp = type->hp;
}
}
}
if (has_flag(MF_REGENERATES_10)) {
if (hp < type->hp) {
if (one_in(2)) {
g->add_msg(_("The %s seems a little healthier."), name().c_str());
}
hp += 10;
if(hp > type->hp) {
hp = type->hp;
}
}
}
// If this critter dies in sunlight, check & assess damage.
if (g->is_in_sunlight(posx(), posy()) && has_flag(MF_SUNDEATH)) {
g->add_msg(_("The %s burns horribly in the sunlight!"), name().c_str());
hp -= 100;
if(hp < 0) {
hp = 0 ;
}
}
if (sp_timeout == 0 && (friendly == 0 || has_flag(MF_FRIENDLY_SPECIAL))) {
mattack ma;
if(!is_hallucination()) {
(ma.*type->sp_attack)(this);
}
}
if (moves < 0) {
return;
}
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect("stunned")) {
stumble(false);
moves = 0;
return;
}
if (has_effect("downed")) {
moves = 0;
return;
}
if (has_effect("bouldering")) {
moves -= 20;
if (moves < 0) {
return;
}
}
if (friendly != 0) {
if (friendly > 0) {
friendly--;
}
friendly_move();
return;
}
bool moved = false;
point next;
int mondex = (plans.size() > 0 ? g->mon_at(plans[0].x, plans[0].y) : -1);
monster_attitude current_attitude = attitude();
if (friendly == 0) {
current_attitude = attitude(&(g->u));
}
// If our plans end in a player, set our attitude to consider that player
if (plans.size() > 0) {
if (plans.back().x == g->u.posx && plans.back().y == g->u.posy) {
current_attitude = attitude(&(g->u));
} else {
for (int i = 0; i < g->active_npc.size(); i++) {
if (plans.back().x == g->active_npc[i]->posx &&
plans.back().y == g->active_npc[i]->posy) {
current_attitude = attitude((g->active_npc[i]));
}
}
}
}
if (current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST)) {
moves -= 100;
stumble(false);
return;
}
if (plans.size() > 0 &&
(mondex == -1 || g->zombie(mondex).friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(plans[0].x, plans[0].y) ||
(plans[0].x == g->u.posx && plans[0].y == g->u.posy) ||
(g->m.has_flag("BASHABLE", plans[0].x, plans[0].y) && has_flag(MF_BASHES)))) {
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
plans.clear();
point tmp = scent_move();
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
plans.clear();
point tmp = wander_next();
if (tmp.x != posx() || tmp.y != posy()) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
// Note: The below works because C++ in A() || B() won't call B() if A() is true
int& x = next.x;
int& y = next.y; // Define alias for x and y
bool did_something = attack_at(x, y) || bash_at(x, y) || move_to(x, y);
if(!did_something) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
}
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.size() == 0)) ||
!moved) {
stumble(moved);
}
}
int monster::move_to(game *g, int x, int y, bool force)
{
// Make sure that we can move there, unless force is true.
if(!force) if(!g->is_empty(x, y) || !can_move_to(g, x, y)) {
return 0;
}
if (has_effect(ME_BEARTRAP)) {
moves = 0;
return 0;
}
if (plans.size() > 0)
plans.erase(plans.begin());
moves -= calc_movecost(g, posx(), posy(), x, y);
if (has_flag(MF_SLUDGETRAIL)) {
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
const int fstr = 3 - (abs(dx) + abs(dy));
if (fstr >= 2) {
g->m.add_field(g, posx() + dx, posy() + dy, fd_sludge, fstr);
}
}
}
}
//Check for moving into/out of water
bool was_water = g->m.is_divable(posx(), posy());
bool will_be_water = g->m.is_divable(x, y);
if(was_water && !will_be_water && g->u_see(x, y)) {
//Use more dramatic messages for swimming monsters
g->add_msg(_("A %s %s from the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("leaps") : _("emerges"),
g->m.tername(posx(), posy()).c_str());
} else if(!was_water && will_be_water && g->u_see(x, y)) {
g->add_msg(_("A %s %s into the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("dives") : _("sinks"),
g->m.tername(x, y).c_str());
}
setpos(x, y);
footsteps(g, x, y);
if(is_hallucination()) {
//Hallucinations don't do any of the stuff after this point
return 1;
}
if (type->size != MS_TINY && g->m.has_flag(sharp, posx(), posy()) && !one_in(4))
hurt(rng(2, 3));
if (type->size != MS_TINY && g->m.has_flag(rough, posx(), posy()) && one_in(6))
hurt(rng(1, 2));
if (!has_flag(MF_DIGS) && !has_flag(MF_FLIES) &&
g->m.tr_at(posx(), posy()) != tr_null) { // Monster stepped on a trap!
trap* tr = g->traps[g->m.tr_at(posx(), posy())];
if (dice(3, type->sk_dodge + 1) < dice(3, tr->avoidance)) {
trapfuncm f;
(f.*(tr->actm))(g, this, posx(), posy());
}
}
// Diggers turn the dirt into dirtmound
if (has_flag(MF_DIGS)){
g->m.ter_set(posx(), posy(), t_dirtmound);
}
// Acid trail monsters leave... a trail of acid
//Why is this being done three times?
if (has_flag(MF_ACIDTRAIL)){
g->m.add_field(g, posx(), posy(), fd_acid, 1);
}
if (has_flag(MF_ACIDTRAIL)){
g->m.add_field(g, posx(), posy(), fd_acid, 1);
}
if (has_flag(MF_ACIDTRAIL)){
g->m.add_field(g, posx(), posy(), fd_acid, 1);
}
return 1;
}
void monster::plan(const std::vector<int> &friendlies)
{
int sightrange = g->light_level();
int closest = -1;
int dist = 1000;
int tc = 0;
int stc = 0;
bool fleeing = false;
if (friendly != 0) { // Target monsters, not the player!
for (int i = 0, numz = g->num_zombies(); i < numz; i++) {
monster *tmp = &(g->zombie(i));
if (tmp->friendly == 0) {
int d = rl_dist(posx(), posy(), tmp->posx(), tmp->posy());
if (d < dist && g->m.sees(posx(), posy(), tmp->posx(), tmp->posy(), sightrange, tc)) {
closest = i;
dist = d;
stc = tc;
}
}
}
if (has_effect("docile")) {
closest = -1;
}
if (closest >= 0) {
set_dest(g->zombie(closest).posx(), g->zombie(closest).posy(), stc);
} else if (friendly > 0 && one_in(3)) {
// Grow restless with no targets
friendly--;
} else if (friendly < 0 && sees_player( tc ) ) {
if (rl_dist(posx(), posy(), g->u.posx, g->u.posy) > 2) {
set_dest(g->u.posx, g->u.posy, tc);
} else {
plans.clear();
}
}
return;
}
// If we can see, and we can see a character, move toward them or flee.
if (can_see() && sees_player( tc ) ) {
dist = rl_dist(posx(), posy(), g->u.posx, g->u.posy);
if (is_fleeing(g->u)) {
// Wander away.
fleeing = true;
set_dest(posx() * 2 - g->u.posx, posy() * 2 - g->u.posy, tc);
} else {
// Chase the player.
closest = -2;
stc = tc;
}
}
for (int i = 0; i < g->active_npc.size(); i++) {
npc *me = (g->active_npc[i]);
int medist = rl_dist(posx(), posy(), me->posx, me->posy);
if ((medist < dist || (!fleeing && is_fleeing(*me))) &&
(can_see() &&
g->m.sees(posx(), posy(), me->posx, me->posy, sightrange, tc))) {
if (is_fleeing(*me)) {
fleeing = true;
set_dest(posx() * 2 - me->posx, posy() * 2 - me->posy, tc);
\
} else {
closest = i;
stc = tc;
}
dist = medist;
}
}
if (!fleeing) {
fleeing = attitude() == MATT_FLEE;
if (can_see()) {
for (int f = 0, numf = friendlies.size(); f < numf; f++) {
const int i = friendlies[f];
monster *mon = &(g->zombie(i));
int mondist = rl_dist(posx(), posy(), mon->posx(), mon->posy());
if (mondist < dist &&
g->m.sees(posx(), posy(), mon->posx(), mon->posy(), sightrange, tc)) {
dist = mondist;
if (fleeing) {
wandx = posx() * 2 - mon->posx();
wandy = posy() * 2 - mon->posy();
wandf = 40;
} else {
closest = -3 - i;
stc = tc;
}
}
}
}
if (closest == -2) {
if (one_in(2)) {//random for the diversity of the trajectory
++stc;
} else {
--stc;
}
set_dest(g->u.posx, g->u.posy, stc);
}
else if (closest <= -3)
set_dest(g->zombie(-3 - closest).posx(), g->zombie(-3 - closest).posy(), stc);
else if (closest >= 0)
set_dest(g->active_npc[closest]->posx, g->active_npc[closest]->posy, stc);
}
}
int monster::print_info(game *g, WINDOW* w, int vStart, int vLines, int column)
{
// First line of w is the border; the next two are terrain info, and after that
// is a blank line. w is 13 characters tall, and we can't use the last one
// because it's a border as well; so we have lines 4 through 11.
// w is also 48 characters wide - 2 characters for border = 46 characters for us
// vStart added because 'help' text in targeting win makes helpful info hard to find
// at a glance.
const int vEnd = vStart + vLines;
mvwprintz(w, vStart++, column, c_white, "%s ", type->name.c_str());
switch (attitude(&(g->u))) {
case MATT_FRIEND:
wprintz(w, h_white, _("Friendly! "));
break;
case MATT_FLEE:
wprintz(w, c_green, _("Fleeing! "));
break;
case MATT_IGNORE:
wprintz(w, c_ltgray, _("Ignoring "));
break;
case MATT_FOLLOW:
wprintz(w, c_yellow, _("Tracking "));
break;
case MATT_ATTACK:
wprintz(w, c_red, _("Hostile! "));
break;
default:
wprintz(w, h_red, "BUG: Behavior unnamed. (monster.cpp:print_info)");
break;
}
if (has_effect(ME_DOWNED))
wprintz(w, h_white, _("On ground"));
else if (has_effect(ME_STUNNED))
wprintz(w, h_white, _("Stunned"));
else if (has_effect(ME_BEARTRAP))
wprintz(w, h_white, _("Trapped"));
std::string damage_info;
nc_color col;
if (hp >= type->hp) {
damage_info = _("It is uninjured");
col = c_green;
} else if (hp >= type->hp * .8) {
damage_info = _("It is lightly injured");
col = c_ltgreen;
} else if (hp >= type->hp * .6) {
damage_info = _("It is moderately injured");
col = c_yellow;
} else if (hp >= type->hp * .3) {
damage_info = _("It is heavily injured");
col = c_yellow;
} else if (hp >= type->hp * .1) {
damage_info = _("It is severly injured");
col = c_ltred;
} else {
damage_info = _("it is nearly dead");
col = c_red;
}
mvwprintz(w, vStart++, column, col, damage_info.c_str());
std::vector<std::string> lines = foldstring(type->description, getmaxx(w) - 1 - column);
int numlines = lines.size();
for (int i = 0; i < numlines && vStart <= vEnd; i++)
mvwprintz(w, vStart++, column, c_white, lines[i].c_str());
return vStart;
}
bool monster::can_hear()
{
return has_flag(MF_HEARS) && !has_effect("deaf");
}
bool monster::can_see()
{
return has_flag(MF_SEES) && !has_effect(ME_BLIND);
}
