bool trap::detect_trap( const tripoint &pos, const player &p ) const
{
// Some decisions are based around:
// * Starting, and thus average perception, is 8.
// * Buried landmines, the silent killer, has a visibility of 10.
// * There will always be a distance malus of 1 unless you're on top of the trap.
// * ...and an average character should at least have a minor chance of
// noticing a buried landmine if standing right next to it.
// Effective Perception...
///\EFFECT_PER increases chance of detecting a trap
return ( p.per_cur - ( p.encumb( bp_eyes ) / 10 ) ) +
// ...small bonus from stimulants...
( p.stim > 10 ? rng( 1, 2 ) : 0 ) +
// ...bonus from trap skill...
///\EFFECT_TRAPS increases chance of detecting a trap
( p.get_skill_level( skill_traps ) * 2 ) +
// ...luck, might be good, might be bad...
rng( -4, 4 ) -
// ...malus if we are tired...
( p.has_effect( effect_lack_sleep ) ? rng( 1, 5 ) : 0 ) -
// ...malus farther we are from trap...
rl_dist( p.pos(), pos ) +
// Police are trained to notice Something Wrong.
( p.has_trait( trait_id( "PROF_POLICE" ) ) ? 1 : 0 ) +
( p.has_trait( trait_id( "PROF_PD_DET" ) ) ? 2 : 0 ) >
// ...must all be greater than the trap visibility.
visibility;
}
bool ma_requirements::is_valid_player( const player &u ) const
{
for( const auto &buff_id : req_buffs ) {
if (!u.has_mabuff(buff_id)) {
return false;
}
}
//A technique is valid if it applies to unarmed strikes, if it applies generally
//to all weapons (such as Ninjutsu sneak attacks or innate weapon techniques like RAPID)
//or if the weapon is flagged as being compatible with the style. Some techniques have
//further restrictions on required weapon properties (is_valid_weapon).
bool cqb = u.has_active_bionic( bionic_id( "bio_cqb" ) );
// There are 4 different cases of "armedness":
// Truly unarmed, unarmed weapon, style-allowed weapon, generic weapon
bool valid_weapon =
( unarmed_allowed && u.unarmed_attack() &&
( !strictly_unarmed || !u.is_armed() ) ) ||
( is_valid_weapon( u.weapon ) &&
( melee_allowed || u.style_selected.obj().has_weapon( u.weapon.typeId() ) ) );
if( !valid_weapon ) {
return false;
}
for( const auto &pr : min_skill ) {
if( ( cqb ? 5 : (int)u.get_skill_level( pr.first ) ) < pr.second ) {
return false;
}
}
return true;
}
bool player_can_build( player &p, const inventory &pinv, const construction &con )
{
if( p.has_trait( "DEBUG_HS" ) ) {
return true;
}
if( p.get_skill_level( con.skill ) < con.difficulty ) {
return false;
}
return con.requirements->can_make_with_inventory( pinv );
}
read_inventory_preset( const player &p ) : pickup_inventory_preset( p ), p( p ) {
static const std::string unknown( _( "<color_dkgray>?</color>" ) );
static const std::string martial_arts( _( "martial arts" ) );
append_cell( [ this, &p ]( const item_location & loc ) -> std::string {
if( loc->type->can_use( "MA_MANUAL" ) ) {
return martial_arts;
}
if( !is_known( loc ) ) {
return unknown;
}
const auto &book = get_book( loc );
if( book.skill && p.get_skill_level( book.skill ).can_train() ) {
return string_format( _( "%s to %d" ), book.skill->name().c_str(), book.level );
}
return std::string();
}, _( "TRAINS" ), unknown );
append_cell( [ this ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
const auto &book = get_book( loc );
const int unlearned = book.recipes.size() - get_known_recipes( book );
return unlearned > 0 ? to_string( unlearned ) : std::string();
}, _( "RECIPES" ), unknown );
append_cell( [ this ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
const int fun = get_book( loc ).fun;
if( fun > 0 ) {
return string_format( "<good>+%d</good>", fun );
} else if( fun < 0 ) {
return string_format( "<bad>%d</bad>", fun );
}
return std::string();
}, _( "FUN" ), unknown );
append_cell( [ this, &p ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
std::vector<std::string> dummy;
const player *reader = p.get_book_reader( *loc, dummy );
if( reader == nullptr ) {
return std::string(); // Just to make sure
}
// Actual reading time (in turns). Can be penalized.
const int actual_turns = p.time_to_read( *loc, *reader ) / MOVES( 1 );
// Theoretical reading time (in turns) based on the reader speed. Free of penalties.
const int normal_turns = get_book( loc ).time * reader->read_speed() / MOVES( 1 );
const std::string duration = calendar( actual_turns ).textify_period();
if( actual_turns > normal_turns ) { // Longer - complicated stuff.
return string_format( "<color_ltred>%s</color>", duration.c_str() );
}
return duration; // Normal speed.
}, _( "CHAPTER IN" ), unknown );
}