std::string direction_suffix( const tripoint& p, const tripoint& q )
{
int dist = square_dist( p, q );
if ( dist <= 0 ) {
return std::string();
}
return string_format( "%d%s", dist, trim( direction_name_short( direction_from( p, q ) ) ).c_str() );
}
std::string overmapbuffer::get_description_at( const tripoint &where )
{
const std::string ter_name = ter( sm_to_omt_copy( where ) )->get_name();
if( where.z != 0 ) {
return ter_name;
}
const auto closest_cref = closest_known_city( where );
if( !closest_cref ) {
return ter_name;
}
const auto &closest_city = *closest_cref.city;
const direction dir = direction_from( closest_cref.abs_sm_pos, where );
const std::string dir_name = direction_name( dir );
const int sm_size = omt_to_sm_copy( closest_cref.city->size );
const int sm_dist = closest_cref.distance;
if( sm_dist <= 3 * sm_size / 4 ) {
if( sm_size >= 16 ) {
// The city is big enough to be split in districts.
if( sm_dist <= sm_size / 4 ) {
//~ First parameter is a terrain name, second parameter is a city name.
return string_format( _( "%1$s in central %2$s" ), ter_name.c_str(), closest_city.name.c_str() );
} else {
//~ First parameter is a terrain name, second parameter is a direction, and third parameter is a city name.
return string_format( _( "%1$s in %2$s %3$s" ), ter_name.c_str(), dir_name.c_str(),
closest_city.name.c_str() );
}
} else {
//~ First parameter is a terrain name, second parameter is a city name.
return string_format( _( "%1$s in %2$s" ), ter_name.c_str(), closest_city.name.c_str() );
}
} else if( sm_dist <= sm_size ) {
if( sm_size >= 8 ) {
// The city is big enough to have outskirts.
//~ First parameter is a terrain name, second parameter is a direction, and third parameter is a city name.
return string_format( _( "%1$s on the %2$s outskirts of %3$s" ), ter_name.c_str(), dir_name.c_str(),
closest_city.name.c_str() );
} else {
//~ First parameter is a terrain name, second parameter is a city name.
return string_format( _( "%1$s in %2$s" ), ter_name.c_str(), closest_city.name.c_str() );
}
}
//~ First parameter is a terrain name, second parameter is a direction, and third parameter is a city name.
return string_format( _( "%1$s %2$s from %3$s" ), ter_name.c_str(), dir_name.c_str(),
closest_city.name.c_str() );
}
void sounds::process_sound_markers( player *p )
{
bool is_deaf = p->is_deaf();
const float volume_multiplier = p->hearing_ability();
const int safe_volume = p->worn_with_flag("PARTIAL_DEAF") ? 100 : 9999;
const int weather_vol = weather_data( g->weather ).sound_attn;
for( const auto &sound_event_pair : sounds_since_last_turn ) {
const int volume = std::min(safe_volume, (int)(sound_event_pair.second.volume * volume_multiplier));
const std::string& sfx_id = sound_event_pair.second.id;
const std::string& sfx_variant = sound_event_pair.second.variant;
const int max_volume = std::max( volume, sound_event_pair.second.volume ); // For deafness checks
int dist = rl_dist( p->pos(), sound_event_pair.first );
bool ambient = sound_event_pair.second.ambient;
// Too far away, we didn't hear it!
if( dist > volume ) {
continue;
}
if( is_deaf ) {
// Has to be here as well to work for stacking deafness (loud noises prolong deafness)
if( !p->is_immune_effect( effect_deaf )
&& rng( ( max_volume - dist ) / 2, ( max_volume - dist ) ) >= 150 ) {
// Prolong deafness, but not as much as if it was freshly applied
int duration = std::min( 40, ( max_volume - dist - 130 ) / 8 );
p->add_effect( effect_deaf, duration );
if( !p->has_trait( "DEADENED" ) ) {
p->add_msg_if_player( m_bad, _( "Your eardrums suddenly ache!" ) );
if( p->get_pain() < 10 ) {
p->mod_pain( rng( 0, 2 ) );
}
}
}
// We're deaf, skip rest of processing.
continue;
}
// Player volume meter includes all sounds from their tile and adjacent tiles
// TODO: Add noises from vehicle player is in.
if( dist <= 1 ) {
p->volume = std::max( p->volume, volume );
}
// Check for deafness
if( !p->is_immune_effect( effect_deaf ) && rng((max_volume - dist) / 2, (max_volume - dist)) >= 150 ) {
int duration = (max_volume - dist - 130) / 4;
p->add_effect( effect_deaf, duration );
if( p->is_deaf() ) {
// Need to check for actual deafness
is_deaf = true;
sfx::do_hearing_loss( duration );
continue;
}
}
// At this point we are dealing with attention (as opposed to physical effects)
// so reduce volume by the amount of ambient noise from the weather.
const int mod_vol = ( sound_event_pair.second.volume - weather_vol ) * volume_multiplier;
// The noise was drowned out by the surroundings.
if( mod_vol - dist < 0 ) {
continue;
}
// See if we need to wake someone up
if( p->has_effect( effect_sleep ) ) {
if( ( !( p->has_trait( "HEAVYSLEEPER" ) ||
p->has_trait( "HEAVYSLEEPER2" ) ) && dice( 2, 15 ) < mod_vol - dist ) ||
( p->has_trait( "HEAVYSLEEPER" ) && dice( 3, 15 ) < mod_vol - dist ) ||
( p->has_trait( "HEAVYSLEEPER2" ) && dice( 6, 15 ) < mod_vol - dist ) ) {
//Not kidding about sleep-thru-firefight
p->wake_up();
add_msg( m_warning, _( "Something is making noise." ) );
} else {
continue;
}
}
const tripoint &pos = sound_event_pair.first;
const std::string &description = sound_event_pair.second.description;
if( !ambient && ( pos != p->pos() ) && !g->m.pl_sees( pos, dist ) ) {
if( p->activity.ignore_trivial != true ) {
std::string query;
if( description.empty() ) {
query = _( "Heard a noise!" );
} else {
query = string_format( _( "Heard %s!" ),
sound_event_pair.second.description.c_str() );
}
if( g->cancel_activity_or_ignore_query( query.c_str() ) ) {
p->activity.ignore_trivial = true;
for( auto activity : p->backlog ) {
activity.ignore_trivial = true;
}
}
}
}
// Only print a description if it exists
if( !description.empty() ) {
// If it came from us, don't print a direction
if( pos == p->pos() ) {
add_msg( _( "You hear %s" ), description.c_str() );
} else {
// Else print a direction as well
std::string direction = direction_name( direction_from( p->pos(), pos ) );
add_msg( m_warning, _( "From the %s you hear %s" ), direction.c_str(), description.c_str() );
}
}
// Play the sound effect, if any.
if( !sfx_id.empty() ) {
// for our sfx API, 100 is "normal" volume, so scale accordingly
int heard_volume = sfx::get_heard_volume( pos );
sfx::play_variant_sound( sfx_id, sfx_variant, heard_volume );
//add_msg("Playing sound effect %s, %s, %d", sfx_id.c_str(), sfx_variant.c_str(), heard_volume);
}
// If Z coord is different, draw even when you can see the source
const bool diff_z = pos.z != p->posz();
// Place footstep markers.
if( pos == p->pos() || p->sees( pos ) ) {
// If we are or can see the source, don't draw a marker.
continue;
}
int err_offset;
if( mod_vol / dist < 2 ) {
err_offset = 3;
} else if( mod_vol / dist < 3 ) {
err_offset = 2;
} else {
err_offset = 1;
}
// Enumerate the valid points the player *cannot* see.
// Unless the source is on a different z-level, then any point is fine
std::vector<tripoint> unseen_points;
tripoint newp = pos;
int &newx = newp.x;
int &newy = newp.y;
for( newx = pos.x - err_offset; newx <= pos.x + err_offset; newx++ ) {
for( newy = pos.y - err_offset; newy <= pos.y + err_offset; newy++ ) {
if( diff_z || !p->sees( newp ) ) {
unseen_points.emplace_back( newp );
}
}
}
// Then place the sound marker in a random one.
if( !unseen_points.empty() ) {
sound_markers.emplace( random_entry( unseen_points ),
sound_event_pair.second );
}
}
sounds_since_last_turn.clear();
}
/**
* Attempts to harm a creature with a projectile.
*
* @param source Pointer to the creature who shot the projectile.
* @param attack A structure describing the attack and its results.
*/
void Creature::deal_projectile_attack( Creature *source, dealt_projectile_attack &attack )
{
const double missed_by = attack.missed_by;
if( missed_by >= 1.0 ) {
// Total miss
return;
}
const projectile &proj = attack.proj;
dealt_damage_instance &dealt_dam = attack.dealt_dam;
const auto &proj_effects = proj.proj_effects;
const bool u_see_this = g->u.sees(*this);
const int avoid_roll = dodge_roll();
// Do dice(10, speed) instead of dice(speed, 10) because speed could potentially be > 10000
const int diff_roll = dice( 10, proj.speed );
// Partial dodge, capped at [0.0, 1.0], added to missed_by
const double dodge_rescaled = avoid_roll / static_cast<double>( diff_roll );
const double goodhit = missed_by + std::max( 0.0, std::min( 1.0, dodge_rescaled ) ) ;
if( goodhit >= 1.0 ) {
// "Avoid" rather than "dodge", because it includes removing self from the line of fire
// rather than just Matrix-style bullet dodging
if( source != nullptr && g->u.sees( *source ) ) {
add_msg_player_or_npc(
m_warning,
_("You avoid %s projectile!"),
_("<npcname> avoids %s projectile."),
source->disp_name(true).c_str() );
} else {
add_msg_player_or_npc(
m_warning,
_("You avoid an incoming projectile!"),
_("<npcname> avoids an incoming projectile.") );
}
attack.missed_by = 1.0; // Arbitrary value
return;
}
// Bounce applies whether it does damage or not.
if( proj.proj_effects.count( "BOUNCE" ) ) {
add_effect( effect_bounced, 1_turns );
}
body_part bp_hit;
double hit_value = missed_by + rng_float(-0.5, 0.5);
// Headshots considered elsewhere
if( hit_value <= 0.4 ) {
bp_hit = bp_torso;
} else if (one_in(4)) {
if( one_in(2)) {
bp_hit = bp_leg_l;
} else {
bp_hit = bp_leg_r;
}
} else {
if( one_in(2)) {
bp_hit = bp_arm_l;
} else {
bp_hit = bp_arm_r;
}
}
double damage_mult = 1.0;
std::string message = "";
game_message_type gmtSCTcolor = m_neutral;
if( goodhit < accuracy_headshot ) {
message = _("Headshot!");
gmtSCTcolor = m_headshot;
damage_mult *= rng_float(1.95, 2.05);
bp_hit = bp_head; // headshot hits the head, of course
} else if( goodhit < accuracy_critical ) {
message = _("Critical!");
gmtSCTcolor = m_critical;
damage_mult *= rng_float(1.5, 2.0);
} else if( goodhit < accuracy_goodhit ) {
message = _("Good hit!");
gmtSCTcolor = m_good;
damage_mult *= rng_float(1, 1.5);
} else if( goodhit < accuracy_standard ) {
damage_mult *= rng_float(0.5, 1);
} else if( goodhit < accuracy_grazing ) {
message = _("Grazing hit.");
gmtSCTcolor = m_grazing;
damage_mult *= rng_float(0, .25);
}
if( source != nullptr && !message.empty() ) {
source->add_msg_if_player(m_good, message.c_str());
}
attack.missed_by = goodhit;
// copy it, since we're mutating
damage_instance impact = proj.impact;
if( damage_mult > 0.0f && proj_effects.count( "NO_DAMAGE_SCALING" ) ) {
damage_mult = 1.0f;
}
impact.mult_damage(damage_mult);
if( proj_effects.count( "NOGIB" ) > 0 ) {
float dmg_ratio = (float)impact.total_damage() / get_hp_max( player::bp_to_hp( bp_hit ) );
if( dmg_ratio > 1.25f ) {
impact.mult_damage( 1.0f / dmg_ratio );
}
}
dealt_dam = deal_damage(source, bp_hit, impact);
dealt_dam.bp_hit = bp_hit;
// Apply ammo effects to target.
if (proj.proj_effects.count("FLAME")) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, rng( 8_turns, 20_turns ), bp_hit );
} else if (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) {
add_effect( effect_onfire, rng( 5_turns, 10_turns ), bp_hit );
}
} else if (proj.proj_effects.count("INCENDIARY") ) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, rng( 2_turns, 6_turns ), bp_hit );
} else if ( (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) &&
one_in(4) ) {
add_effect( effect_onfire, rng( 1_turns, 4_turns ), bp_hit );
}
} else if (proj.proj_effects.count("IGNITE")) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, 6_turns, bp_hit );
} else if (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) {
add_effect( effect_onfire, 10_turns, bp_hit );
}
}
if( bp_hit == bp_head && proj_effects.count( "BLINDS_EYES" ) ) {
// TODO: Change this to require bp_eyes
add_env_effect( effect_blind, bp_eyes, 5, rng( 3_turns, 10_turns ) );
}
if( proj_effects.count( "APPLY_SAP" ) ) {
add_effect( effect_sap, 1_turns * dealt_dam.total_damage() );
}
int stun_strength = 0;
if (proj.proj_effects.count("BEANBAG")) {
stun_strength = 4;
}
if (proj.proj_effects.count("LARGE_BEANBAG")) {
stun_strength = 16;
}
if( stun_strength > 0 ) {
switch( get_size() ) {
case MS_TINY:
stun_strength *= 4;
break;
case MS_SMALL:
stun_strength *= 2;
break;
case MS_MEDIUM:
default:
break;
case MS_LARGE:
stun_strength /= 2;
break;
case MS_HUGE:
stun_strength /= 4;
break;
}
add_effect( effect_stunned, 1_turns * rng( stun_strength / 2, stun_strength ) );
}
if(u_see_this) {
if( damage_mult == 0 ) {
if( source != nullptr ) {
add_msg( source->is_player() ? _("You miss!") : _("The shot misses!") );
}
} else if( dealt_dam.total_damage() == 0 ) {
//~ 1$ - monster name, 2$ - character's bodypart or monster's skin/armor
add_msg( _("The shot reflects off %1$s %2$s!"), disp_name(true).c_str(),
is_monster() ?
skin_name().c_str() :
body_part_name_accusative(bp_hit).c_str() );
} else if( is_player() ) {
//monster hits player ranged
//~ Hit message. 1$s is bodypart name in accusative. 2$d is damage value.
add_msg_if_player(m_bad, _( "You were hit in the %1$s for %2$d damage." ),
body_part_name_accusative(bp_hit).c_str(),
dealt_dam.total_damage());
} else if( source != nullptr ) {
if( source->is_player() ) {
//player hits monster ranged
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(dealt_dam.total_damage(), get_hp_max(), true).first,
m_good, message, gmtSCTcolor);
if (get_hp() > 0) {
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(get_hp(), get_hp_max(), true).first, m_good,
//~ "hit points", used in scrolling combat text
_("hp"), m_neutral, "hp");
} else {
SCT.removeCreatureHP();
}
add_msg(m_good, _("You hit %s for %d damage."),
disp_name().c_str(), dealt_dam.total_damage());
} else if( u_see_this ) {
//~ 1$ - shooter, 2$ - target
add_msg(_("%1$s shoots %2$s."),
source->disp_name().c_str(), disp_name().c_str());
}
}
}
check_dead_state();
attack.hit_critter = this;
attack.missed_by = goodhit;
}
direction direction_from(int x1, int y1, int x2, int y2)
{
return direction_from(tripoint(x1, y1, 0), tripoint(x2, y2, 0));
}
int Creature::deal_projectile_attack(Creature *source, double missed_by,
const projectile &proj, dealt_damage_instance &dealt_dam)
{
bool u_see_this = g->u_see(this);
body_part bp_hit;
int side = rng(0, 1);
// do 10,speed because speed could potentially be > 10000
if (dodge_roll() >= dice(10, proj.speed)) {
if (is_player())
add_msg(_("You dodge %s projectile!"),
source->disp_name(true).c_str());
else if (u_see_this)
add_msg(_("%s dodges %s projectile."),
disp_name().c_str(), source->disp_name(true).c_str());
return 0;
}
// Bounce applies whether it does damage or not.
if (proj.proj_effects.count("BOUNCE")) {
add_effect("bounced", 1);
}
double hit_value = missed_by + rng_float(-0.5, 0.5);
// headshots considered elsewhere
if (hit_value <= 0.4) {
bp_hit = bp_torso;
} else if (one_in(4)) {
bp_hit = bp_legs;
} else {
bp_hit = bp_arms;
}
double monster_speed_penalty = std::max(double(get_speed()) / 80., 1.0);
double goodhit = missed_by / monster_speed_penalty;
double damage_mult = 1.0;
std::string message = "";
game_message_type gmtSCTcolor = m_neutral;
if (goodhit <= .1) {
message = _("Headshot!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_headshot;
damage_mult *= rng_float(2.45, 3.35);
bp_hit = bp_head; // headshot hits the head, of course
} else if (goodhit <= .2) {
message = _("Critical!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_critical;
damage_mult *= rng_float(1.75, 2.3);
} else if (goodhit <= .4) {
message = _("Good hit!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_good;
damage_mult *= rng_float(1, 1.5);
} else if (goodhit <= .6) {
damage_mult *= rng_float(0.5, 1);
} else if (goodhit <= .8) {
message = _("Grazing hit.");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_grazing;
damage_mult *= rng_float(0, .25);
} else {
damage_mult *= 0;
}
// copy it, since we're mutating
damage_instance impact = proj.impact;
if( item(proj.ammo->id, 0).has_flag("NOGIB") ) {
impact.add_effect("NOGIB");
}
impact.mult_damage(damage_mult);
dealt_dam = deal_damage(source, bp_hit, side, impact);
dealt_dam.bp_hit = bp_hit;
// Apply ammo effects to target.
const std::string target_material = get_material();
if (proj.proj_effects.count("FLAME")) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood" ) ) {
add_effect("onfire", rng(8, 20));
} else if (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) {
add_effect("onfire", rng(5, 10));
}
} else if (proj.proj_effects.count("INCENDIARY") ) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood") ) {
add_effect("onfire", rng(2, 6));
} else if ( (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) &&
one_in(4) ) {
add_effect("onfire", rng(1, 4));
}
} else if (proj.proj_effects.count("IGNITE")) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood") ) {
add_effect("onfire", rng(6, 6));
} else if (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) {
add_effect("onfire", rng(10, 10));
}
}
int stun_strength = 0;
if (proj.proj_effects.count("BEANBAG")) {
stun_strength = 4;
}
if(proj.proj_effects.count("WHIP")) {
stun_strength = rng(4, 10);
}
if (proj.proj_effects.count("LARGE_BEANBAG")) {
stun_strength = 16;
}
if( stun_strength > 0 ) {
switch( get_size() ) {
case MS_TINY:
stun_strength *= 4;
break;
case MS_SMALL:
stun_strength *= 2;
break;
case MS_MEDIUM:
default:
break;
case MS_LARGE:
stun_strength /= 2;
break;
case MS_HUGE:
stun_strength /= 4;
break;
}
add_effect( "stunned", rng(stun_strength / 2, stun_strength) );
}
if(u_see_this) {
if (damage_mult == 0) {
if(source != NULL) {
add_msg(source->is_player() ? _("You miss!") : _("The shot misses!"));
}
} else if (dealt_dam.total_damage() == 0) {
add_msg(_("The shot reflects off %s %s!"), disp_name(true).c_str(),
skin_name().c_str());
} else if (source != NULL) {
if (source->is_player()) {
//player hits monster ranged
nc_color color;
std::string health_bar = "";
get_HP_Bar(dealt_dam.total_damage(), this->get_hp_max(), color, health_bar, true);
SCT.add(this->xpos(),
this->ypos(),
direction_from(0, 0, this->xpos() - source->xpos(), this->ypos() - source->ypos()),
health_bar, m_good,
message, gmtSCTcolor);
if (this->get_hp() > 0) {
get_HP_Bar(this->get_hp(), this->get_hp_max(), color, health_bar, true);
SCT.add(this->xpos(),
this->ypos(),
direction_from(0, 0, this->xpos() - source->xpos(), this->ypos() - source->ypos()),
health_bar, m_good,
"hp", m_neutral,
"hp");
} else {
SCT.removeCreatureHP();
}
add_msg(m_good, _("You hit the %s for %d damage."),
disp_name().c_str(), dealt_dam.total_damage());
} else if(this->is_player()) {
//monster hits player ranged
add_msg_if_player( m_bad, _( "You were hit in the %s for %d damage." ),
body_part_name( bp_hit, side ).c_str( ),
dealt_dam.total_damage( ) );
} else if( u_see_this ) {
add_msg(_("%s shoots %s."),
source->disp_name().c_str(), disp_name().c_str());
}
}
}
return 0;
}
direction direction_from(tripoint const &p, tripoint const &q)
{
// Note: Z coord has to be inverted either here or in direction defintions
return direction_from(q.x - p.x, q.y - p.y, -(q.z - p.z) );
}
direction direction_from(int const x1, int const y1, int const x2, int const y2) noexcept
{
return direction_from(x2 - x1, y2 - y1);
}
