bool repair_part( vehicle &veh, vehicle_part &pt, Character &who_c )
{
// @todo: Get rid of this cast after moving relevant functions down to Character
player &who = ( player & )who_c;
int part_index = veh.index_of_part( &pt );
auto &vp = pt.info();
// @todo: Expose base part damage somewhere, don't recalculate it here
const auto reqs = pt.is_broken() ?
vp.install_requirements() :
vp.repair_requirements() * pt.damage_level( 4 );
inventory map_inv;
map_inv.form_from_map( who.pos(), PICKUP_RANGE );
if( !reqs.can_make_with_inventory( who.crafting_inventory() ) ) {
who.add_msg_if_player( m_info, _( "You don't meet the requirements to repair the %s." ),
pt.name().c_str() );
return false;
}
// consume items extracting any base item (which we will need if replacing broken part)
item base( vp.item );
for( const auto &e : reqs.get_components() ) {
for( auto &obj : who.consume_items( who.select_item_component( e, 1, map_inv ), 1 ) ) {
if( obj.typeId() == vp.item ) {
base = obj;
}
}
}
for( const auto &e : reqs.get_tools() ) {
who.consume_tools( who.select_tool_component( e, 1, map_inv ), 1 );
}
who.invalidate_crafting_inventory();
for( const auto &sk : pt.is_broken() ? vp.install_skills : vp.repair_skills ) {
who.practice( sk.first, calc_xp_gain( vp, sk.first ) );
}
// If part is broken, it will be destroyed and references invalidated
std::string partname = pt.name();
if( pt.is_broken() ) {
const int dir = pt.direction;
point loc = pt.mount;
auto replacement_id = pt.info().get_id();
g->m.spawn_items( who.pos(), pt.pieces_for_broken_part() );
veh.remove_part( part_index );
const int partnum = veh.install_part( loc, replacement_id, std::move( base ) );
veh.parts[partnum].direction = dir;
veh.part_removal_cleanup();
} else {
veh.set_hp( pt, pt.info().durability );
}
// @todo: NPC doing that
who.add_msg_if_player( m_good, _( "You repair the %1$s's %2$s." ), veh.name.c_str(),
partname.c_str() );
return true;
}
void craft_command::execute()
{
if( empty() ) {
return;
}
bool need_selections = true;
inventory map_inv;
map_inv.form_from_map( crafter->pos(), PICKUP_RANGE );
if( has_cached_selections() ) {
std::vector<comp_selection<item_comp>> missing_items = check_item_components_missing( map_inv );
std::vector<comp_selection<tool_comp>> missing_tools = check_tool_components_missing( map_inv );
if( missing_items.empty() && missing_tools.empty() ) {
// All items we used previously are still there, so we don't need to do selection.
need_selections = false;
} else if( !query_continue( missing_items, missing_tools ) ) {
return;
}
}
const auto needs = rec->requirements();
if( need_selections ) {
item_selections.clear();
for( const auto &it : needs.get_components() ) {
comp_selection<item_comp> is = crafter->select_item_component( it, batch_size, map_inv, true );
if( is.use_from == cancel ) {
return;
}
item_selections.push_back( is );
}
tool_selections.clear();
for( const auto &it : needs.get_tools() ) {
comp_selection<tool_comp> ts = crafter->select_tool_component(
it, batch_size, map_inv, DEFAULT_HOTKEYS, true );
if( ts.use_from == cancel ) {
return;
}
tool_selections.push_back( ts );
}
}
auto activity = player_activity( is_long ? ACT_LONGCRAFT : ACT_CRAFT,
rec->batch_time( batch_size ),
-1, INT_MIN, rec->ident() );
activity.values.push_back( batch_size );
crafter->assign_activity( activity );
/* legacy support for lua bindings to last_batch and lastrecipe */
crafter->last_batch = batch_size;
crafter->lastrecipe = rec->ident();
}
void player::complete_disassemble( int item_pos, const tripoint &loc,
bool from_ground, const recipe &dis )
{
// Get the proper recipe - the one for disassembly, not assembly
const auto dis_requirements = dis.disassembly_requirements();
item &org_item = get_item_for_uncraft( *this, item_pos, loc, from_ground );
bool filthy = org_item.is_filthy();
if( org_item.is_null() ) {
add_msg( _( "The item has vanished." ) );
activity.set_to_null();
return;
}
if( org_item.typeId() != dis.result ) {
add_msg( _( "The item might be gone, at least it is not at the expected position anymore." ) );
activity.set_to_null();
return;
}
// Make a copy to keep its data (damage/components) even after it
// has been removed.
item dis_item = org_item;
float component_success_chance = std::min( std::pow( 0.8, dis_item.damage() ), 1.0 );
add_msg( _( "You disassemble the %s into its components." ), dis_item.tname().c_str() );
// Remove any batteries, ammo and mods first
remove_ammo( &dis_item, *this );
remove_radio_mod( dis_item, *this );
if( dis_item.count_by_charges() ) {
// remove the charges that one would get from crafting it
org_item.charges -= dis.create_result().charges;
}
// remove the item, except when it's counted by charges and still has some
if( !org_item.count_by_charges() || org_item.charges <= 0 ) {
if( from_ground ) {
g->m.i_rem( loc, item_pos );
} else {
i_rem( item_pos );
}
}
// Consume tool charges
for( const auto &it : dis_requirements.get_tools() ) {
consume_tools( it );
}
// add the components to the map
// Player skills should determine how many components are returned
int skill_dice = 2 + get_skill_level( dis.skill_used ) * 3;
skill_dice += get_skill_level( dis.skill_used );
// Sides on dice is 16 plus your current intelligence
///\EFFECT_INT increases success rate for disassembling items
int skill_sides = 16 + int_cur;
int diff_dice = dis.difficulty;
int diff_sides = 24; // 16 + 8 (default intelligence)
// disassembly only nets a bit of practice
if( dis.skill_used ) {
practice( dis.skill_used, ( dis.difficulty ) * 2, dis.difficulty );
}
for( const auto &altercomps : dis_requirements.get_components() ) {
const item_comp comp = find_component( altercomps, dis_item );
int compcount = comp.count;
item newit( comp.type, calendar::turn );
// Counted-by-charge items that can be disassembled individually
// have their component count multiplied by the number of charges.
if( dis_item.count_by_charges() && dis.has_flag( "UNCRAFT_SINGLE_CHARGE" ) ) {
compcount *= std::min( dis_item.charges, dis.create_result().charges );
}
// Compress liquids and counted-by-charges items into one item,
// they are added together on the map anyway and handle_liquid
// should only be called once to put it all into a container at once.
if( newit.count_by_charges() || newit.made_of( LIQUID ) ) {
newit.charges = compcount;
compcount = 1;
} else if( !newit.craft_has_charges() && newit.charges > 0 ) {
// tools that can be unloaded should be created unloaded,
// tools that can't be unloaded will keep their default charges.
newit.charges = 0;
}
for( ; compcount > 0; compcount-- ) {
const bool comp_success = ( dice( skill_dice, skill_sides ) > dice( diff_dice, diff_sides ) );
if( dis.difficulty != 0 && !comp_success ) {
add_msg( m_bad, _( "You fail to recover %s." ), newit.tname().c_str() );
continue;
}
const bool dmg_success = component_success_chance > rng_float( 0, 1 );
if( !dmg_success ) {
// Show reason for failure (damaged item, tname contains the damage adjective)
//~ %1s - material, %2$s - disassembled item
add_msg( m_bad, _( "You fail to recover %1$s from the %2$s." ), newit.tname().c_str(),
dis_item.tname().c_str() );
continue;
}
// Use item from components list, or (if not contained)
// use newit, the default constructed.
item act_item = newit;
if( filthy ) {
act_item.item_tags.insert( "FILTHY" );
}
for( item::t_item_vector::iterator a = dis_item.components.begin(); a != dis_item.components.end();
++a ) {
if( a->type == newit.type ) {
act_item = *a;
dis_item.components.erase( a );
break;
}
}
int veh_part = -1;
vehicle *veh = g->m.veh_at( pos(), veh_part );
if( veh != nullptr ) {
veh_part = veh->part_with_feature( veh_part, "CARGO" );
}
if( act_item.made_of( LIQUID ) ) {
g->handle_all_liquid( act_item, PICKUP_RANGE );
} else if( veh_part != -1 && veh->add_item( veh_part, act_item ) ) {
// add_item did put the items in the vehicle, nothing further to be done
} else {
// TODO: For items counted by charges, add as much as we can to the vehicle, and
// the rest on the ground (see dropping code and @vehicle::add_charges)
g->m.add_item_or_charges( pos(), act_item );
}
}
}
if( !dis.learn_by_disassembly.empty() && !knows_recipe( &dis ) ) {
if( can_decomp_learn( dis ) ) {
// @todo: make this depend on intelligence
if( one_in( 4 ) ) {
learn_recipe( &recipe_dict[ dis.ident() ] );
add_msg( m_good, _( "You learned a recipe from disassembling it!" ) );
} else {
add_msg( m_info, _( "You might be able to learn a recipe if you disassemble another." ) );
}
} else {
add_msg( m_info, _( "If you had better skills, you might learn a recipe next time." ) );
}
}
}
