/*
Function: friendly_move
The per-turn movement and action calculation of any friendly monsters.
*/
void monster::friendly_move()
{
tripoint p;
bool moved = false;
//If we successfully calculated a plan in the generic monster movement function, begin executing it.
if( !plans.empty() && ( plans[0] != g->u.pos3() ) &&
( can_move_to( plans[0] ) ||
( ( has_flag( MF_BASHES ) || has_flag( MF_BORES ) ) &&
g->m.bash_rating( bash_estimate(), plans[0] ) >= 0 ) ) ) {
p = plans[0];
plans.erase( plans.begin() );
moved = true;
} else {
//Otherwise just stumble around randomly until we formulate a plan.
moves -= 100;
stumble( moved );
}
if( moved ) {
const bool pacified = has_effect( "pacified" );
const bool did_something =
( !pacified && attack_at( p ) ) ||
( !pacified && bash_at( p ) ) ||
move_to( p );
//If all else fails in our plan (an issue with pathfinding maybe) stumble around instead.
if( !did_something ) {
stumble( moved );
moves -= 100;
}
}
}
/*
Function: friendly_move
The per-turn movement and action calculation of any friendly monsters.
*/
void monster::friendly_move()
{
point next;
bool moved = false;
//If we successfully calculated a plan in the generic monster movement function, begin executing it.
if (!plans.empty() && (plans[0].x != g->u.posx() || plans[0].y != g->u.posy()) &&
(can_move_to(plans[0].x, plans[0].y) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), plans[0].x, plans[0].y) >= 0))) {
next = plans[0];
plans.erase(plans.begin());
moved = true;
} else {
//Otherwise just stumble around randomly until we formulate a plan.
moves -= 100;
stumble(moved);
}
if (moved) {
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 all else fails in our plan (an issue with pathfinding maybe) stumble around instead.
if(!did_something) {
stumble(moved);
moves -= 100;
}
}
}
point monster::scent_move()
{
std::vector<point> smoves;
int maxsmell = 10; // Squares with smell 0 are not eligible targets.
int smell_threshold = 200; // Squares at or above this level are ineligible.
if (has_flag(MF_KEENNOSE)) {
maxsmell = 1;
smell_threshold = 400;
}
int minsmell = 9999;
point pbuff, next(-1, -1);
int smell;
const bool fleeing = is_fleeing(g->u);
if( !fleeing && g->scent( posx(), posy() ) > smell_threshold ) {
return next;
}
for (int x = -1; x <= 1; x++) {
for (int y = -1; y <= 1; y++) {
const int nx = posx() + x;
const int ny = posy() + y;
smell = g->scent(nx, ny);
int mon = g->mon_at(nx, ny);
if( (mon == -1 || g->zombie(mon).friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(nx, ny) || (nx == g->u.posx() && ny == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), nx, ny) >= 0))) {
if ((!fleeing && smell > maxsmell) || (fleeing && smell < minsmell)) {
smoves.clear();
pbuff.x = nx;
pbuff.y = ny;
smoves.push_back(pbuff);
maxsmell = smell;
minsmell = smell;
} else if ((!fleeing && smell == maxsmell) || (fleeing && smell == minsmell)) {
pbuff.x = nx;
pbuff.y = ny;
smoves.push_back(pbuff);
}
}
}
}
if (!smoves.empty()) {
int nextsq = rng(0, smoves.size() - 1);
next = smoves[nextsq];
}
return next;
}
tripoint monster::scent_move()
{
// @todo Remove when scentmap is 3D
if( abs( posz() - g->get_levz() ) > 1 ) {
return { -1, -1, INT_MIN };
}
std::vector<tripoint> smoves;
int bestsmell = 10; // Squares with smell 0 are not eligible targets.
int smell_threshold = 200; // Squares at or above this level are ineligible.
if( has_flag( MF_KEENNOSE ) ) {
bestsmell = 1;
smell_threshold = 400;
}
const bool fleeing = is_fleeing( g->u );
if( fleeing ) {
bestsmell = g->scent.get( pos() );
}
tripoint next( -1, -1, posz() );
if( ( !fleeing && g->scent.get( pos() ) > smell_threshold ) ||
( fleeing && bestsmell == 0 ) ) {
return next;
}
const bool can_bash = bash_skill() > 0;
for( const auto &dest : g->m.points_in_radius( pos(), 1, 1 ) ) {
int smell = g->scent.get( dest );
if( g->m.valid_move( pos(), dest, can_bash, true ) &&
( can_move_to( dest ) || ( dest == g->u.pos() ) ||
( can_bash && g->m.bash_rating( bash_estimate(), dest ) > 0 ) ) ) {
if( ( !fleeing && smell > bestsmell ) || ( fleeing && smell < bestsmell ) ) {
smoves.clear();
smoves.push_back( dest );
bestsmell = smell;
} else if( ( !fleeing && smell == bestsmell ) || ( fleeing && smell == bestsmell ) ) {
smoves.push_back( dest );
}
}
}
return random_entry( smoves, next );
}
tripoint monster::scent_move()
{
std::vector<tripoint> smoves;
int bestsmell = 10; // Squares with smell 0 are not eligible targets.
int smell_threshold = 200; // Squares at or above this level are ineligible.
if( has_flag( MF_KEENNOSE ) ) {
bestsmell = 1;
smell_threshold = 400;
}
const bool fleeing = is_fleeing( g->u );
if( fleeing ) {
bestsmell = g->scent( pos() );
}
tripoint next( -1, -1, posz() );
if( ( !fleeing && g->scent( pos() ) > smell_threshold ) ||
( fleeing && bestsmell == 0 ) ) {
return next;
}
const bool can_bash = has_flag( MF_BASHES ) || has_flag( MF_BORES );
for( const auto &dest : g->m.points_in_radius( pos(), 1 ) ) {
int smell = g->scent( dest );
int mon = g->mon_at( dest );
if( ( mon == -1 || g->zombie( mon ).friendly != 0 || has_flag( MF_ATTACKMON ) ) &&
( can_move_to( dest ) || ( dest == g->u.pos3() ) ||
( can_bash && g->m.bash_rating( bash_estimate(), dest ) >= 0 ) ) ) {
if( ( !fleeing && smell > bestsmell ) || ( fleeing && smell < bestsmell ) ) {
smoves.clear();
smoves.push_back( dest );
bestsmell = smell;
} else if( ( !fleeing && smell == bestsmell ) || ( fleeing && smell == bestsmell ) ) {
smoves.push_back( dest );
}
}
}
return random_entry( smoves, next );
}
point monster::wander_next()
{
point next;
bool xbest = true;
if (abs(wandy - posy()) > abs(wandx - posx())) {// which is more important
xbest = false;
}
next.x = posx();
next.y = posy();
int x = posx(), x2 = posx() - 1, x3 = posx() + 1;
int y = posy(), y2 = posy() - 1, y3 = posy() + 1;
if (wandx < posx()) {
x--; x2++;
}
if (wandx > posx()) {
x++; x2++; x3 -= 2;
}
if (wandy < posy()) {
y--; y2++;
}
if (wandy > posy()) {
y++; y2++; y3 -= 2;
}
if (xbest) {
if (can_move_to(x, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y) >= 0)) {
next.x = x;
next.y = y;
} else if (can_move_to(x, y2) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y2) >= 0)) {
next.x = x;
next.y = y2;
} else if (can_move_to(x2, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x2, y) >= 0)) {
next.x = x2;
next.y = y;
} else if (can_move_to(x, y3) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y3) >= 0)) {
next.x = x;
next.y = y3;
} else if (can_move_to(x3, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x3, y) >= 0)) {
next.x = x3;
next.y = y;
}
} else {
if (can_move_to(x, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y) >= 0)) {
next.x = x;
next.y = y;
} else if (can_move_to(x2, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x2, y) >= 0)) {
next.x = x2;
next.y = y;
} else if (can_move_to(x, y2) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y2) >= 0)) {
next.x = x;
next.y = y2;
} else if (can_move_to(x3, y) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x3, y) >= 0)) {
next.x = x3;
next.y = y;
} else if (can_move_to(x, y3) || (x == g->u.posx() && y == g->u.posy()) ||
((has_flag(MF_BASHES) || has_flag(MF_BORES)) &&
g->m.bash_rating(bash_estimate(), x, y3) >= 0)) {
next.x = x;
next.y = y3;
}
}
return next;
}
// 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);
}
}
// 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 ) && !g->m.has_flag( TFLAG_SEALED, pos() ) &&
g->m.has_items( pos() ) ) {
if( g->u.sees( *this ) ) {
add_msg( _( "The %s flows around the objects on the floor and they are quickly dissolved!" ),
name().c_str() );
}
static const auto volume_per_hp = units::from_milliliter( 250 );
for( auto &elem : g->m.i_at( pos() ) ) {
hp += elem.volume() / volume_per_hp; // Yeah this means it can get more HP than normal.
}
g->m.i_clear( pos() );
}
const bool pacified = has_effect( effect_pacified );
// First, use the special attack, if we can!
// The attack may change `monster::special_attacks` (e.g. by transforming
// this into another monster type). Therefor we can not iterate over it
// directly and instead iterate over the map from the monster type
// (properties of monster types should never change).
for( const auto &sp_type : type->special_attacks ) {
const std::string &special_name = sp_type.first;
const auto local_iter = special_attacks.find( special_name );
if( local_iter == special_attacks.end() ) {
continue;
}
mon_special_attack &local_attack_data = local_iter->second;
if( !local_attack_data.enabled ) {
continue;
}
if( local_attack_data.cooldown > 0 ) {
local_attack_data.cooldown--;
}
if( local_attack_data.cooldown == 0 && !pacified && !is_hallucination() ) {
if( !sp_type.second->call( *this ) ) {
continue;
}
// `special_attacks` might have changed at this point. Sadly `reset_special`
// doesn't check the attack name, so we need to do it here.
if( special_attacks.count( special_name ) == 0 ) {
continue;
}
reset_special( special_name );
}
}
// The monster can sometimes hang in air due to last fall being blocked
const bool can_fly = has_flag( MF_FLIES );
if( !can_fly && g->m.has_flag( TFLAG_NO_FLOOR, pos() ) ) {
g->m.creature_on_trap( *this, false );
}
if( moves < 0 ) {
return;
}
// TODO: Move this to attack_at/move_to/etc. functions
bool attacking = false;
if( !move_effects( attacking ) ) {
moves = 0;
return;
}
if( has_flag( MF_IMMOBILE ) ) {
moves = 0;
return;
}
if( has_effect( effect_stunned ) ) {
stumble();
moves = 0;
return;
}
if( friendly > 0 ) {
--friendly;
}
// Set attitude to attitude to our current target
monster_attitude current_attitude = attitude( nullptr );
if( !wander() ) {
if( goal == g->u.pos() ) {
current_attitude = attitude( &( g->u ) );
} else {
for( auto &i : g->active_npc ) {
if( goal == i->pos() ) {
current_attitude = attitude( i );
}
}
}
}
if( current_attitude == MATT_IGNORE ||
( current_attitude == MATT_FOLLOW && rl_dist( pos(), goal ) <= MONSTER_FOLLOW_DIST ) ) {
moves -= 100;
stumble();
return;
}
bool moved = false;
tripoint destination;
// If true, don't try to greedily avoid locally bad paths
bool pathed = false;
if( !wander() ) {
while( !path.empty() && path.front() == pos() ) {
path.erase( path.begin() );
}
const auto &pf_settings = get_pathfinding_settings();
if( pf_settings.max_dist >= rl_dist( pos(), goal ) &&
( path.empty() || rl_dist( pos(), path.front() ) >= 2 || path.back() != goal ) ) {
// We need a new path
path = g->m.route( pos(), goal, pf_settings, get_path_avoid() );
}
// Try to respect old paths, even if we can't pathfind at the moment
if( !path.empty() && path.back() == goal ) {
destination = path.front();
moved = true;
pathed = true;
} else {
// Straight line forward, probably because we can't pathfind (well enough)
destination = goal;
moved = true;
}
}
if( !moved && 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.
unset_dest();
tripoint tmp = scent_move();
if( tmp.x != -1 ) {
destination = tmp;
moved = true;
}
}
if( wandf > 0 && !moved ) { // No LOS, no scent, so as a fall-back follow sound
unset_dest();
if( wander_pos != pos() ) {
destination = wander_pos;
moved = true;
}
}
if( !g->m.has_zlevels() ) {
// Otherwise weird things happen
destination.z = posz();
}
tripoint next_step;
const bool staggers = has_flag( MF_STUMBLES );
if( moved ) {
// Implement both avoiding obstacles and staggering.
moved = false;
float switch_chance = 0.0;
const bool can_bash = bash_skill() > 0;
// This is a float and using trig_dist() because that Does the Right Thing(tm)
// in both circular and roguelike distance modes.
const float distance_to_target = trig_dist( pos(), destination );
for( const tripoint &candidate : squares_closer_to( pos(), destination ) ) {
if( candidate.z != posz() ) {
bool can_z_move = true;
if( !g->m.valid_move( pos(), candidate, false, true ) ) {
// Can't phase through floor
can_z_move = false;
}
if( can_z_move && !can_fly && candidate.z > posz() && !g->m.has_floor_or_support( candidate ) ) {
// Can't "jump" up a whole z-level
can_z_move = false;
}
// Last chance - we can still do the z-level stair teleport bullshit that isn't removed yet
// @todo Remove z-level stair bullshit teleport after aligning all stairs
if( !can_z_move &&
posx() / ( SEEX * 2 ) == candidate.x / ( SEEX * 2 ) &&
posy() / ( SEEY * 2 ) == candidate.y / ( SEEY * 2 ) ) {
const tripoint &upper = candidate.z > posz() ? candidate : pos();
const tripoint &lower = candidate.z > posz() ? pos() : candidate;
if( g->m.has_flag( TFLAG_GOES_DOWN, upper ) && g->m.has_flag( TFLAG_GOES_UP, lower ) ) {
can_z_move = true;
}
}
if( !can_z_move ) {
continue;
}
}
// A flag to allow non-stumbling critters to stumble when the most direct choice is bad.
bool bad_choice = false;
const Creature *target = g->critter_at( candidate, is_hallucination() );
if( target != nullptr ) {
const Creature::Attitude att = attitude_to( *target );
if( att == A_HOSTILE ) {
// When attacking an adjacent enemy, we're direct.
moved = true;
next_step = candidate;
break;
} else if( att == A_FRIENDLY && ( target->is_player() || target->is_npc() ) ) {
continue; // Friendly firing the player or an NPC is illegal for gameplay reasons
} else if( !has_flag( MF_ATTACKMON ) && !has_flag( MF_PUSH_MON ) ) {
// Bail out if there's a non-hostile monster in the way and we're not pushy.
continue;
}
// Friendly fire and pushing are always bad choices - they take a lot of time
bad_choice = true;
}
// Bail out if we can't move there and we can't bash.
if( !pathed && !can_move_to( candidate ) ) {
if( !can_bash ) {
continue;
}
const int estimate = g->m.bash_rating( bash_estimate(), candidate );
if( estimate <= 0 ) {
continue;
}
if( estimate < 5 ) {
bad_choice = true;
}
}
const float progress = distance_to_target - trig_dist( candidate, destination );
// The x2 makes the first (and most direct) path twice as likely,
// since the chance of switching is 1/1, 1/4, 1/6, 1/8
switch_chance += progress * 2;
// Randomly pick one of the viable squares to move to weighted by distance.
if( moved == false || x_in_y( progress, switch_chance ) ) {
moved = true;
next_step = candidate;
// If we stumble, pick a random square, otherwise take the first one,
// which is the most direct path.
// Except if the direct path is bad, then check others
// Or if the path is given by pathfinder
if( !staggers && ( !bad_choice || pathed ) ) {
break;
}
}
}
}
// 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
const bool did_something =
( !pacified && attack_at( next_step ) ) ||
( !pacified && bash_at( next_step ) ) ||
( !pacified && push_to( next_step, 0, 0 ) ) ||
move_to( next_step, false, get_stagger_adjust( pos(), destination, next_step ) );
if( !did_something ) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
stumble();
path.clear();
}
}
tripoint monster::wander_next()
{
tripoint next = pos();
bool xbest = true;
if( abs( wander_pos.y - posy() ) > abs( wander_pos.x - posx() ) ) {
// Which is more important
xbest = false;
}
int x = posx(), x2 = posx() - 1, x3 = posx() + 1;
int y = posy(), y2 = posy() - 1, y3 = posy() + 1;
int z = posz();
// Used to avoid checking same points 3 times when moving in a straight line
// *_move is true if pos*() != wander_pos.*
bool x_move = true;
bool y_move = true;
bool z_move = true;
if( wander_pos.x < posx() ) {
x--;
x2++;
} else if( wander_pos.x > posx() ) {
x++;
x2++;
x3 -= 2;
} else {
x_move = false;
}
if( wander_pos.y < posy() ) {
y--;
y2++;
} else if( wander_pos.y > posy() ) {
y++;
y2++;
y3 -= 2;
} else {
y_move = false;
}
if( wander_pos.z < posz() ) {
z--;
} else if( wander_pos.z > posz() ) {
z++;
} else {
z_move = false;
}
if( !x_move && !y_move && !z_move ) {
return next;
}
// Any creature can "fly" downwards
const bool flies = z < posz() || has_flag( MF_FLIES );
const bool climbs = has_flag( MF_CLIMBS );
const bool canbash = has_flag( MF_BASHES ) || has_flag( MF_BORES );
const int bash_est = bash_estimate();
// Check if we can move into position, attack player on position or bash position
// If yes, set next to this position and return true, otherwise return false
const auto try_pos = [&]( const int x, const int y, const int z ) {
tripoint dest( x, y, z );
if( ( canbash && g->m.bash_rating( bash_est, dest ) > 0 ) ||
( ( flies || g->m.has_floor_or_support( dest ) ) &&
can_move_to( dest ) ) ) {
next = dest;
return true;
}
return false;
};
bool found = false;
const bool can_climb = z_move && (flies || climbs || g->m.has_flag( TFLAG_RAMP, pos() ));
if( z_move && g->m.valid_move( pos(), tripoint( posx(), posy(), z ), false, can_climb ) ) {
found = true;
if( ( x_move || y_move ) && try_pos( x, y, z ) ) {
} else if( y_move && try_pos( x, y2, z ) ) {
} else if( x_move && try_pos( x2, y, z ) ) {
} else if( y_move && try_pos( x, y3, z ) ) {
} else if( x_move && try_pos( x3, y, z ) ) {
} else if( try_pos( posx(), posy(), z ) ) {
} else {
found = false;
}
}
if( found ) {
return next;
}
if( xbest ) {
if( ( x_move || y_move ) && try_pos( x, y, posz() ) ) {
// Do nothing in each of those ifs, the if-else is just for convenience
} else if( y_move && try_pos( x, y2, posz() ) ) {
} else if( x_move && try_pos( x2, y, posz() ) ) {
} else if( y_move && try_pos( x, y3, posz() ) ) {
} else if( x_move && try_pos( x3, y, posz() ) ) {
}
} else {
if( ( x_move || y_move ) && try_pos( x, y, posz() ) ) {
} else if( x_move && try_pos( x2, y, posz() ) ) {
} else if( y_move && try_pos( x, y2, posz() ) ) {
} else if( x_move && try_pos( x3, y, posz() ) ) {
} else if( y_move && try_pos( x, y3, posz() ) ) {
}
}
return next;
}
// 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 ) && !g->m.has_flag( TFLAG_SEALED, pos() ) ) {
if( !g->m.i_at( pos3() ).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( pos3() ) ) {
hp += elem.volume(); // Yeah this means it can get more HP than normal.
}
g->m.i_clear( pos3() );
}
}
static const std::string pacified_string = "pacified";
const bool pacified = has_effect( pacified_string );
// 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 && !pacified && !is_hallucination() ) {
type->sp_attack[i]( this, i );
}
}
// The monster can sometimes hang in air due to last fall being blocked
const bool can_fly = has_flag( MF_FLIES );
if( !can_fly && g->m.has_flag( TFLAG_NO_FLOOR, pos() ) ) {
g->m.creature_on_trap( *this, false );
}
if( moves < 0 ) {
return;
}
// TODO: Move this to attack_at/move_to/etc. functions
bool attacking = false;
if( !move_effects(attacking) ) {
moves = 0;
return;
}
if( has_flag( MF_IMMOBILE ) ) {
moves = 0;
return;
}
static const std::string stun_string = "stunned";
if( has_effect( stun_string ) ) {
stumble();
moves = 0;
return;
}
if( friendly > 0 ) {
--friendly;
}
// Set attitude to attitude to our current target
monster_attitude current_attitude = attitude( nullptr );
if( !wander() ) {
if( goal == g->u.pos3() ) {
current_attitude = attitude( &( g->u ) );
} else {
for( auto &i : g->active_npc ) {
if( goal == i->pos3() ) {
current_attitude = attitude( i );
}
}
}
}
if( current_attitude == MATT_IGNORE ||
( current_attitude == MATT_FOLLOW && rl_dist(pos(), goal) <= MONSTER_FOLLOW_DIST ) ) {
moves -= 100;
stumble();
return;
}
bool moved = false;
tripoint destination;
// CONCRETE PLANS - Most likely based on sight
if( !wander() ) {
destination = goal;
moved = true;
}
if( !moved && 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.
unset_dest();
tripoint tmp = scent_move();
if( tmp.x != -1 ) {
destination = tmp;
moved = true;
}
}
if( wandf > 0 && !moved ) { // No LOS, no scent, so as a fall-back follow sound
unset_dest();
tripoint tmp = wander_next();
if( tmp != pos() ) {
destination = tmp;
moved = true;
}
}
tripoint next_step;
if( moved ) {
// Implement both avoiding obstacles and staggering.
moved = false;
float switch_chance = 0.0;
const bool can_bash = has_flag( MF_BASHES ) || has_flag( MF_BORES );
// This is a float and using trig_dist() because that Does the Right Thing(tm)
// in both circular and roguelike distance modes.
const float distance_to_target = trig_dist( pos(), destination );
for( const tripoint &candidate : squares_closer_to( pos(), destination ) ) {
const Creature *target = g->critter_at( candidate, is_hallucination() );
// When attacking an adjacent enemy, we're direct.
if( target != nullptr && attitude_to( *target ) == A_HOSTILE ) {
moved = true;
next_step = candidate;
break;
}
// Bail out if we can't move there and we can't bash.
if( !can_move_to( candidate ) &&
!(can_bash && g->m.bash_rating( bash_estimate(), candidate ) >= 0 ) ) {
continue;
}
// Bail out if there's a non-hostile monster in the way and we're not pushy.
if( target != nullptr && attitude_to( *target ) != A_HOSTILE &&
!has_flag( MF_ATTACKMON ) && !has_flag( MF_PUSH_MON ) ) {
continue;
}
float progress = distance_to_target - trig_dist( candidate, destination );
switch_chance += progress;
// Randomly pick one of the viable squares to move to weighted by distance.
if( x_in_y( progress, switch_chance ) ) {
moved = true;
next_step = candidate;
// If we stumble, pick a random square, otherwise take the first one,
// which is the most direct path.
if( !has_flag( MF_STUMBLES ) ) {
break;
}
}
}
}
// 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
// move_to() uses the slope to determine some move speed scaling.
const float slope = (destination.x > destination.y) ?
(float)destination.y / (float)destination.x :
(float)destination.x / (float)destination.y;
const bool did_something =
( !pacified && attack_at( next_step ) ) ||
( !pacified && bash_at( next_step ) ) ||
( !pacified && push_to( next_step, 0, 0 ) ) ||
move_to( next_step, false, slope );
if( !did_something ) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
stumble();
}
}
// 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 ) && !g->m.has_flag( TFLAG_SEALED, pos() ) ) {
if( !g->m.i_at( pos3() ).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( pos3() ) ) {
hp += elem.volume(); // Yeah this means it can get more HP than normal.
}
g->m.i_clear( pos3() );
}
}
static const std::string pacified_string = "pacified";
const bool pacified = has_effect( pacified_string );
// 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 && !pacified && !is_hallucination() ) {
type->sp_attack[i]( this, i );
}
}
// The monster can sometimes hang in air due to last fall being blocked
const bool can_fly = has_flag( MF_FLIES );
if( !can_fly && g->m.has_flag( TFLAG_NO_FLOOR, pos() ) ) {
g->m.creature_on_trap( *this, false );
}
if( moves < 0 ) {
return;
}
// TODO: Move this to attack_at/move_to/etc. functions
bool attacking = false;
if( !move_effects(attacking) ) {
moves = 0;
return;
}
if( has_flag( MF_IMMOBILE ) ) {
moves = 0;
return;
}
static const std::string stun_string = "stunned";
if( has_effect( stun_string ) ) {
stumble( false );
moves = 0;
return;
}
if( friendly != 0 ) {
if( friendly > 0 ) {
friendly--;
}
friendly_move();
return;
}
bool moved = false;
tripoint next;
// Set attitude to attitude to our current target
monster_attitude current_attitude = attitude( nullptr );
if( !plans.empty() ) {
if( plans.back() == g->u.pos3() ) {
current_attitude = attitude( &( g->u ) );
} else {
for( auto &i : g->active_npc ) {
if( plans.back() == i->pos3() ) {
current_attitude = attitude( i );
}
}
}
}
if( current_attitude == MATT_IGNORE ||
( current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST ) ) {
moves -= 100;
stumble( false );
return;
}
// Fix possibly invalid plans
// Also make sure the monster won't act across z-levels when it shouldn't.
// Don't do it in plan(), because the mon can still use ranged special attacks using
// the plans that are not valid for travel/melee.
const bool can_bash = has_flag( MF_BASHES ) || has_flag( MF_BORES );
if( !plans.empty() &&
!g->m.valid_move( pos(), plans[0], can_bash, can_fly ) ) {
plans.clear();
}
int mondex = !plans.empty() ? g->mon_at( plans[0], is_hallucination() ) : -1;
auto mon_att = mondex != -1 ? attitude_to( g->zombie( mondex ) ) : A_HOSTILE;
if( !plans.empty() &&
( mon_att == A_HOSTILE || has_flag( MF_ATTACKMON ) || has_flag( MF_PUSH_MON ) ) &&
( can_move_to( plans[0] ) ||
( plans[0] == g->u.pos3() ) ||
( ( has_flag( MF_BASHES ) || has_flag( MF_BORES ) ) &&
g->m.bash_rating( bash_estimate(), plans[0] ) >= 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();
tripoint 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();
tripoint tmp = wander_next();
if( tmp != pos() ) {
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
const bool did_something =
( !pacified && attack_at( next ) ) ||
( !pacified && bash_at( next ) ) ||
( !pacified && push_to( next, 0, 0 ) ) ||
move_to( next );
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 );
}
}
