/* This call is in-efficient when doing it for multiple items with the same map inventory.
In that case, consider using select_tool_component with 1 pre-created map inventory, and then passing the results
to consume_tools */
void player::consume_tools( const std::vector<tool_comp> &tools, int batch,
const std::string &hotkeys )
{
inventory map_inv;
map_inv.form_from_map( pos(), PICKUP_RANGE );
consume_tools( select_tool_component( tools, batch, map_inv, hotkeys ), batch );
}
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." ) );
}
}
}
void player::complete_craft()
{
const recipe *making = &recipe_dict[ activity.name ]; // Which recipe is it?
int batch_size = activity.values.front();
if( making == nullptr ) {
debugmsg( "no recipe with id %s found", activity.name.c_str() );
activity.set_to_null();
return;
}
int secondary_dice = 0;
int secondary_difficulty = 0;
for( const auto &pr : making->required_skills ) {
secondary_dice += get_skill_level( pr.first );
secondary_difficulty += pr.second;
}
// # of dice is 75% primary skill, 25% secondary (unless secondary is null)
int skill_dice;
if( secondary_difficulty > 0 ) {
skill_dice = get_skill_level( making->skill_used ) * 3 + secondary_dice;
} else {
skill_dice = get_skill_level( making->skill_used ) * 4;
}
auto helpers = g->u.get_crafting_helpers();
for( const npc *np : helpers ) {
if( np->get_skill_level( making->skill_used ) >=
get_skill_level( making->skill_used ) ) {
// NPC assistance is worth half a skill level
skill_dice += 2;
add_msg( m_info, _( "%s helps with crafting..." ), np->name.c_str() );
break;
}
}
// farsightedness can impose a penalty on electronics and tailoring success
// it's equivalent to a 2-rank electronics penalty, 1-rank tailoring
if( has_trait( trait_id( "HYPEROPIC" ) ) && !is_wearing( "glasses_reading" ) &&
!is_wearing( "glasses_bifocal" ) && !has_effect( effect_contacts ) ) {
int main_rank_penalty = 0;
if( making->skill_used == skill_id( "electronics" ) ) {
main_rank_penalty = 2;
} else if( making->skill_used == skill_id( "tailor" ) ) {
main_rank_penalty = 1;
}
skill_dice -= main_rank_penalty * 4;
}
// It's tough to craft with paws. Fortunately it's just a matter of grip and fine-motor,
// not inability to see what you're doing
if( has_trait( trait_PAWS ) || has_trait( trait_PAWS_LARGE ) ) {
int paws_rank_penalty = 0;
if( has_trait( trait_PAWS_LARGE ) ) {
paws_rank_penalty += 1;
}
if( making->skill_used == skill_id( "electronics" )
|| making->skill_used == skill_id( "tailor" )
|| making->skill_used == skill_id( "mechanics" ) ) {
paws_rank_penalty += 1;
}
skill_dice -= paws_rank_penalty * 4;
}
// Sides on dice is 16 plus your current intelligence
///\EFFECT_INT increases crafting success chance
int skill_sides = 16 + int_cur;
int diff_dice;
if( secondary_difficulty > 0 ) {
diff_dice = making->difficulty * 3 + secondary_difficulty;
} else {
// Since skill level is * 4 also
diff_dice = making->difficulty * 4;
}
int diff_sides = 24; // 16 + 8 (default intelligence)
int skill_roll = dice( skill_dice, skill_sides );
int diff_roll = dice( diff_dice, diff_sides );
if( making->skill_used ) {
const double batch_mult = 1 + time_to_craft( *making, batch_size ) / 30000.0;
//normalize experience gain to crafting time, giving a bonus for longer crafting
practice( making->skill_used, ( int )( ( making->difficulty * 15 + 10 ) * batch_mult ),
( int )making->difficulty * 1.25 );
//NPCs assisting or watching should gain experience...
for( auto &elem : helpers ) {
//If the NPC can understand what you are doing, they gain more exp
if( elem->get_skill_level( making->skill_used ) >= making->difficulty ) {
elem->practice( making->skill_used,
( int )( ( making->difficulty * 15 + 10 ) * batch_mult *
.50 ), ( int )making->difficulty * 1.25 );
if( batch_size > 1 ) {
add_msg( m_info, _( "%s assists with crafting..." ), elem->name.c_str() );
}
if( batch_size == 1 ) {
add_msg( m_info, _( "%s could assist you with a batch..." ), elem->name.c_str() );
}
//NPCs around you understand the skill used better
} else {
elem->practice( making->skill_used,
( int )( ( making->difficulty * 15 + 10 ) * batch_mult * .15 ),
( int )making->difficulty * 1.25 );
add_msg( m_info, _( "%s watches you craft..." ), elem->name.c_str() );
}
}
}
// Messed up badly; waste some components.
if( making->difficulty != 0 && diff_roll > skill_roll * ( 1 + 0.1 * rng( 1, 5 ) ) ) {
add_msg( m_bad, _( "You fail to make the %s, and waste some materials." ),
item::nname( making->result ).c_str() );
if( last_craft->has_cached_selections() ) {
last_craft->consume_components();
} else {
// @todo Guarantee that selections are cached
const auto &req = making->requirements();
for( const auto &it : req.get_components() ) {
consume_items( it, batch_size );
}
for( const auto &it : req.get_tools() ) {
consume_tools( it, batch_size );
}
}
activity.set_to_null();
return;
// Messed up slightly; no components wasted.
} else if( diff_roll > skill_roll ) {
add_msg( m_neutral, _( "You fail to make the %s, but don't waste any materials." ),
item::nname( making->result ).c_str() );
//this method would only have been called from a place that nulls activity.type,
//so it appears that it's safe to NOT null that variable here.
//rationale: this allows certain contexts (e.g. ACT_LONGCRAFT) to distinguish major and minor failures
return;
}
// If we're here, the craft was a success!
// Use up the components and tools
std::list<item> used;
if( !last_craft->has_cached_selections() ) {
// This should fail and return, but currently crafting_command isn't saved
// Meaning there are still cases where has_cached_selections will be false
// @todo Allow saving last_craft and debugmsg+fail craft if selection isn't cached
if( !has_trait( trait_id( "DEBUG_HS" ) ) ) {
const auto &req = making->requirements();
for( const auto &it : req.get_components() ) {
std::list<item> tmp = consume_items( it, batch_size );
used.splice( used.end(), tmp );
}
for( const auto &it : req.get_tools() ) {
consume_tools( it, batch_size );
}
}
} else if( !has_trait( trait_id( "DEBUG_HS" ) ) ) {
used = last_craft->consume_components();
if( used.empty() ) {
return;
}
}
// Set up the new item, and assign an inventory letter if available
std::vector<item> newits = making->create_results( batch_size );
bool first = true;
float used_age_tally = 0;
int used_age_count = 0;
size_t newit_counter = 0;
for( item &newit : newits ) {
// messages, learning of recipe, food spoilage calc only once
if( first ) {
first = false;
if( knows_recipe( making ) ) {
add_msg( _( "You craft %s from memory." ), newit.type_name( 1 ).c_str() );
} else {
add_msg( _( "You craft %s using a book as a reference." ), newit.type_name( 1 ).c_str() );
// If we made it, but we don't know it,
// we're making it from a book and have a chance to learn it.
// Base expected time to learn is 1000*(difficulty^4)/skill/int moves.
// This means time to learn is greatly decreased with higher skill level,
// but also keeps going up as difficulty goes up.
// Worst case is lvl 10, which will typically take
// 10^4/10 (1,000) minutes, or about 16 hours of crafting it to learn.
int difficulty = has_recipe( making, crafting_inventory(), helpers );
///\EFFECT_INT increases chance to learn recipe when crafting from a book
if( x_in_y( making->time, ( 1000 * 8 *
( difficulty * difficulty * difficulty * difficulty ) ) /
( std::max( get_skill_level( making->skill_used ).level(), 1 ) * std::max( get_int(), 1 ) ) ) ) {
learn_recipe( ( recipe * )making );
add_msg( m_good, _( "You memorized the recipe for %s!" ),
newit.type_name( 1 ).c_str() );
}
}
for( auto &elem : used ) {
if( elem.goes_bad() ) {
used_age_tally += elem.get_relative_rot();
++used_age_count;
}
}
}
// Don't store components for things made by charges,
// don't store components for things that can't be uncrafted.
if( recipe_dictionary::get_uncraft( making->result ) && !newit.count_by_charges() ) {
// Setting this for items counted by charges gives only problems:
// those items are automatically merged everywhere (map/vehicle/inventory),
// which would either loose this information or merge it somehow.
set_components( newit.components, used, batch_size, newit_counter );
newit_counter++;
}
finalize_crafted_item( newit, used_age_tally, used_age_count );
set_item_inventory( newit );
}
if( making->has_byproducts() ) {
std::vector<item> bps = making->create_byproducts( batch_size );
for( auto &bp : bps ) {
finalize_crafted_item( bp, used_age_tally, used_age_count );
set_item_inventory( bp );
}
}
inv.restack( this );
}
void game::complete_craft()
{
recipe* making = recipes[u.activity.index]; // Which recipe is it?
// # of dice is 75% primary skill, 25% secondary (unless secondary is null)
int skill_dice = u.sklevel[making->sk_primary] * 3;
if (making->sk_secondary == sk_null)
skill_dice += u.sklevel[making->sk_primary];
else
skill_dice += u.sklevel[making->sk_secondary];
// Sides on dice is 16 plus your current intelligence
int skill_sides = 16 + u.int_cur;
int diff_dice = making->difficulty * 4; // Since skill level is * 4 also
int diff_sides = 24; // 16 + 8 (default intelligence)
int skill_roll = dice(skill_dice, skill_sides);
int diff_roll = dice(diff_dice, diff_sides);
if (making->sk_primary != sk_null)
u.practice(making->sk_primary, making->difficulty * 5 + 20);
if (making->sk_secondary != sk_null)
u.practice(making->sk_secondary, 5);
// Messed up badly; waste some components.
if (making->difficulty != 0 && diff_roll > skill_roll * (1 + 0.1 * rng(1, 5))) {
add_msg("You fail to make the %s, and waste some materials.",
itypes[making->result]->name.c_str());
for (int i = 0; i < 5; i++) {
if (making->components[i].size() > 0) {
std::vector<component> copy = making->components[i];
for (int j = 0; j < copy.size(); j++)
copy[j].count = rng(0, copy[j].count);
consume_items(this, copy);
}
if (making->tools[i].size() > 0)
consume_tools(this, making->tools[i]);
}
u.activity.type = ACT_NULL;
return;
// Messed up slightly; no components wasted.
} else if (diff_roll > skill_roll) {
add_msg("You fail to make the %s, but don't waste any materials.",
itypes[making->result]->name.c_str());
u.activity.type = ACT_NULL;
return;
}
// If we're here, the craft was a success!
// Use up the components and tools
for (int i = 0; i < 5; i++) {
if (making->components[i].size() > 0)
consume_items(this, making->components[i]);
if (making->tools[i].size() > 0)
consume_tools(this, making->tools[i]);
}
// Set up the new item, and pick an inventory letter
int iter = 0;
item newit(itypes[making->result], turn, nextinv);
if (!newit.craft_has_charges())
newit.charges = 0;
do {
newit.invlet = nextinv;
advance_nextinv();
iter++;
} while (u.has_item(newit.invlet) && iter < 52);
//newit = newit.in_its_container(&itypes);
if (newit.made_of(LIQUID))
handle_liquid(newit, false, false);
else {
// We might not have space for the item
if (iter == 52 || u.volume_carried()+newit.volume() > u.volume_capacity()) {
add_msg("There's no room in your inventory for the %s, so you drop it.",
newit.tname().c_str());
m.add_item(u.posx, u.posy, newit);
} else if (u.weight_carried() + newit.volume() > u.weight_capacity()) {
add_msg("The %s is too heavy to carry, so you drop it.",
newit.tname().c_str());
m.add_item(u.posx, u.posy, newit);
} else {
u.i_add(newit);
add_msg("%c - %s", newit.invlet, newit.tname().c_str());
}
}
}
