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 ); }