void mdeath::normal( monster &z )
{
if( z.no_corpse_quiet ) {
return;
}
if( z.type->in_species( ZOMBIE ) ) {
sfx::play_variant_sound( "mon_death", "zombie_death", sfx::get_heard_volume( z.pos() ) );
}
if( g->u.sees( z ) ) {
//Currently it is possible to get multiple messages that a monster died.
add_msg( m_good, _( "The %s dies!" ), z.name() );
}
const int max_hp = std::max( z.get_hp_max(), 1 );
const float overflow_damage = std::max( -z.get_hp(), 0 );
const float corpse_damage = 2.5 * overflow_damage / max_hp;
const bool pulverized = corpse_damage > 5 && overflow_damage > z.get_hp_max();
z.bleed(); // leave some blood if we have to
if( !pulverized ) {
make_mon_corpse( z, static_cast<int>( std::floor( corpse_damage * itype::damage_scale ) ) );
}
// if mdeath::splatter was set along normal makes sure it is not called twice
bool splatt = false;
for( const auto &deathfunction : z.type->dies ) {
if( deathfunction == mdeath::splatter ) {
splatt = true;
}
}
if( !splatt ) {
splatter( z );
}
}
void mdeath::guilt( monster &z )
{
const int MAX_GUILT_DISTANCE = 5;
int kill_count = g->kill_count( z.type->id );
int maxKills = 100; // this is when the player stop caring altogether.
// different message as we kill more of the same monster
std::string msg = _( "You feel guilty for killing %s." ); // default guilt message
game_message_type msgtype = m_bad; // default guilt message type
std::map<int, std::string> guilt_tresholds;
guilt_tresholds[75] = _( "You feel ashamed for killing %s." );
guilt_tresholds[50] = _( "You regret killing %s." );
guilt_tresholds[25] = _( "You feel remorse for killing %s." );
if( g->u.has_trait( trait_PSYCHOPATH ) || g->u.has_trait( trait_PRED3 ) ||
g->u.has_trait( trait_PRED4 ) ) {
return;
}
if( rl_dist( z.pos(), g->u.pos() ) > MAX_GUILT_DISTANCE ) {
// Too far away, we can deal with it.
return;
}
if( z.get_hp() >= 0 ) {
// We probably didn't kill it
return;
}
if( kill_count >= maxKills ) {
// player no longer cares
if( kill_count == maxKills ) {
//~ Message after killing a lot of monsters which would normally affect the morale negatively. %s is the monster name, it will be pluralized with a number of 100.
add_msg( m_good, _( "After killing so many bloody %s you no longer care "
"about their deaths anymore." ), z.name( maxKills ) );
}
return;
} else if( ( g->u.has_trait( trait_PRED1 ) ) || ( g->u.has_trait( trait_PRED2 ) ) ) {
msg = ( _( "Culling the weak is distasteful, but necessary." ) );
msgtype = m_neutral;
} else {
msgtype = m_bad;
for( auto &guilt_treshold : guilt_tresholds ) {
if( kill_count >= guilt_treshold.first ) {
msg = guilt_treshold.second;
break;
}
}
}
add_msg( msgtype, msg, z.name() );
int moraleMalus = -50 * ( 1.0 - ( static_cast<float>( kill_count ) / maxKills ) );
int maxMalus = -250 * ( 1.0 - ( static_cast<float>( kill_count ) / maxKills ) );
time_duration duration = 30_minutes * ( 1.0 - ( static_cast<float>( kill_count ) / maxKills ) );
time_duration decayDelay = 3_minutes * ( 1.0 - ( static_cast<float>( kill_count ) / maxKills ) );
if( z.type->in_species( ZOMBIE ) ) {
moraleMalus /= 10;
if( g->u.has_trait( trait_PACIFIST ) ) {
moraleMalus *= 5;
} else if( g->u.has_trait( trait_PRED1 ) ) {
moraleMalus /= 4;
} else if( g->u.has_trait( trait_PRED2 ) ) {
moraleMalus /= 5;
}
}
g->u.add_morale( MORALE_KILLED_MONSTER, moraleMalus, maxMalus, duration, decayDelay );
}
void mdeath::normal( monster &z )
{
if( z.no_corpse_quiet ) {
return;
}
if( z.type->in_species( ZOMBIE ) ) {
sfx::play_variant_sound( "mon_death", "zombie_death", sfx::get_heard_volume( z.pos() ) );
}
if( g->u.sees( z ) ) {
//Currently it is possible to get multiple messages that a monster died.
add_msg( m_good, _( "The %s dies!" ), z.name().c_str() );
}
const int max_hp = std::max( z.get_hp_max(), 1 );
const float overflow_damage = std::max( -z.get_hp(), 0 );
const float corpse_damage = 2.5 * overflow_damage / max_hp;
const bool pulverized = corpse_damage > 5 && overflow_damage > z.get_hp_max();
z.bleed(); // leave some blood if we have to
if( !pulverized ) {
make_mon_corpse( z, int( std::floor( corpse_damage ) ) );
}
// Limit chunking to flesh, veggy and insect creatures until other kinds are supported.
const std::vector<material_id> gib_mats = {{
material_id( "flesh" ), material_id( "hflesh" ),
material_id( "veggy" ), material_id( "iflesh" ),
material_id( "bone" )
}};
const bool gibbable = !z.type->has_flag( MF_NOGIB ) &&
std::any_of( gib_mats.begin(), gib_mats.end(), [&z]( const material_id &gm ) {
return z.made_of( gm );
} );
const field_id type_blood = z.bloodType();
const field_id type_gib = z.gibType();
if( gibbable ) {
const auto area = g->m.points_in_radius( z.pos(), 1 );
int number_of_gibs = std::min( std::floor( corpse_damage ) - 1, 1 + max_hp / 5.0f );
if( pulverized && z.type->size >= MS_MEDIUM ) {
number_of_gibs += rng( 1, 6 );
sfx::play_variant_sound( "mon_death", "zombie_gibbed", sfx::get_heard_volume( z.pos() ) );
}
for( int i = 0; i < number_of_gibs; ++i ) {
g->m.add_splatter( type_gib, random_entry( area ), rng( 1, i + 1 ) );
g->m.add_splatter( type_blood, random_entry( area ) );
}
}
const int num_chunks = z.type->get_meat_chunks_count();
if( pulverized && gibbable ) {
const itype_id meat = z.type->get_meat_itype();
const item chunk( meat );
for( int i = 0; i < num_chunks; i++ ) {
tripoint tarp( z.pos() + point( rng( -3, 3 ), rng( -3, 3 ) ) );
const auto traj = line_to( z.pos(), tarp );
for( size_t j = 0; j < traj.size(); j++ ) {
tarp = traj[j];
if( one_in( 2 ) && type_blood != fd_null ) {
g->m.add_splatter( type_blood, tarp );
} else {
g->m.add_splatter( type_gib, tarp, rng( 1, j + 1 ) );
}
if( g->m.impassable( tarp ) ) {
g->m.bash( tarp, 3 );
if( g->m.impassable( tarp ) ) {
// Target is obstacle, not destroyed by bashing,
// stop trajectory in front of it, if this is the first
// point (e.g. wall adjacent to monster) , make it invalid.
if( j > 0 ) {
tarp = traj[j - 1];
} else {
tarp = tripoint_min;
}
break;
}
}
}
if( tarp != tripoint_min ) {
g->m.add_item_or_charges( tarp, chunk );
}
}
}
}
void mdeath::splatter( monster &z )
{
const bool gibbable = !z.type->has_flag( MF_NOGIB );
const int max_hp = std::max( z.get_hp_max(), 1 );
const float overflow_damage = std::max( -z.get_hp(), 0 );
const float corpse_damage = 2.5 * overflow_damage / max_hp;
bool pulverized = corpse_damage > 5 && overflow_damage > z.get_hp_max();
// make sure that full splatter happens when this is a set death function, not part of normal
for( const auto &deathfunction : z.type->dies ) {
if( deathfunction == mdeath::splatter ) {
pulverized = true;
}
}
const field_id type_blood = z.bloodType();
const field_id type_gib = z.gibType();
if( gibbable ) {
const auto area = g->m.points_in_radius( z.pos(), 1 );
int number_of_gibs = std::min( std::floor( corpse_damage ) - 1, 1 + max_hp / 5.0f );
if( pulverized && z.type->size >= MS_MEDIUM ) {
number_of_gibs += rng( 1, 6 );
sfx::play_variant_sound( "mon_death", "zombie_gibbed", sfx::get_heard_volume( z.pos() ) );
}
for( int i = 0; i < number_of_gibs; ++i ) {
g->m.add_splatter( type_gib, random_entry( area ), rng( 1, i + 1 ) );
g->m.add_splatter( type_blood, random_entry( area ) );
}
}
// 1% of the weight of the monster is the base, with overflow damage as a multiplier
int gibbed_weight = rng( 0, round( to_gram( z.get_weight() ) / 100 *
( overflow_damage / max_hp + 1 ) ) );
// limit gibbing to 15%
gibbed_weight = std::min( gibbed_weight, to_gram( z.get_weight() ) * 15 / 100 );
if( pulverized && gibbable ) {
float overflow_ratio = overflow_damage / max_hp + 1;
int gib_distance = round( rng( 2, 4 ) );
for( const auto &entry : *z.type->harvest ) {
// only flesh and bones survive.
if( entry.type == "flesh" || entry.type == "bone" ) {
// the larger the overflow damage, the less you get
const int chunk_amt = entry.mass_ratio / overflow_ratio / 10 * to_gram(
z.get_weight() ) / to_gram( ( item::find_type( entry.drop ) )->weight );
scatter_chunks( entry.drop, chunk_amt, z, gib_distance, chunk_amt / ( gib_distance - 1 ) );
gibbed_weight -= entry.mass_ratio / overflow_ratio / 20 * to_gram( z.get_weight() );
}
}
if( gibbed_weight > 0 ) {
scatter_chunks( "ruined_chunks",
gibbed_weight / to_gram( ( item::find_type( "ruined_chunks" ) ) ->weight ), z, gib_distance,
gibbed_weight / to_gram( ( item::find_type( "ruined_chunks" ) )->weight ) / ( gib_distance + 1 ) );
}
// add corpse with gib flag
item corpse = item::make_corpse( z.type->id, calendar::turn, z.unique_name );
// Set corpse to damage that aligns with being pulped
corpse.set_damage( 4000 );
corpse.set_flag( "GIBBED" );
if( z.has_effect( effect_no_ammo ) ) {
corpse.set_var( "no_ammo", "no_ammo" );
}
g->m.add_item_or_charges( z.pos(), corpse );
}
}
void mdeath::splatter( monster &z )
{
// Limit chunking to flesh, veggy and insect creatures until other kinds are supported.
const std::vector<material_id> gib_mats = {{
material_id( "flesh" ), material_id( "hflesh" ),
material_id( "veggy" ), material_id( "iflesh" ),
material_id( "bone" )
}
};
const bool gibbable = !z.type->has_flag( MF_NOGIB ) &&
std::any_of( gib_mats.begin(), gib_mats.end(), [&z]( const material_id & gm ) {
return z.made_of( gm );
} );
const int max_hp = std::max( z.get_hp_max(), 1 );
const float overflow_damage = std::max( -z.get_hp(), 0 );
const float corpse_damage = 2.5 * overflow_damage / max_hp;
bool pulverized = corpse_damage > 5 && overflow_damage > z.get_hp_max();
// make sure that full splatter happens when this is a set death function, not part of normal
for( const auto &deathfunction : z.type->dies ) {
if( deathfunction == mdeath::splatter ) {
pulverized = true;
}
}
const field_id type_blood = z.bloodType();
const field_id type_gib = z.gibType();
if( gibbable ) {
const auto area = g->m.points_in_radius( z.pos(), 1 );
int number_of_gibs = std::min( std::floor( corpse_damage ) - 1, 1 + max_hp / 5.0f );
if( pulverized && z.type->size >= MS_MEDIUM ) {
number_of_gibs += rng( 1, 6 );
sfx::play_variant_sound( "mon_death", "zombie_gibbed", sfx::get_heard_volume( z.pos() ) );
}
for( int i = 0; i < number_of_gibs; ++i ) {
g->m.add_splatter( type_gib, random_entry( area ), rng( 1, i + 1 ) );
g->m.add_splatter( type_blood, random_entry( area ) );
}
}
int num_chunks = rng( 0, z.type->get_meat_chunks_count() / 4 );
num_chunks = std::min( num_chunks, 10 );
if( pulverized && gibbable ) {
const itype_id meat = z.type->get_meat_itype();
const item chunk( meat );
for( int i = 0; i < num_chunks; i++ ) {
bool drop_chunks = true;
tripoint tarp( z.pos() + point( rng( -3, 3 ), rng( -3, 3 ) ) );
const auto traj = line_to( z.pos(), tarp );
for( size_t j = 0; j < traj.size(); j++ ) {
tarp = traj[j];
if( one_in( 2 ) && type_blood != fd_null ) {
g->m.add_splatter( type_blood, tarp );
} else {
g->m.add_splatter( type_gib, tarp, rng( 1, j + 1 ) );
}
if( g->m.impassable( tarp ) ) {
g->m.bash( tarp, 3 );
if( g->m.impassable( tarp ) ) {
// Target is obstacle, not destroyed by bashing,
// stop trajectory in front of it, if this is the first
// point (e.g. wall adjacent to monster), don't drop anything on it
if( j > 0 ) {
tarp = traj[j - 1];
} else {
drop_chunks = false;
}
break;
}
}
}
if( drop_chunks ) {
g->m.add_item_or_charges( tarp, chunk );
}
}
}
}