Creature *Creature::auto_find_hostile_target( int range, int &boo_hoo, int area )
{
Creature *target = nullptr;
player &u = g->u; // Could easily protect something that isn't the player
constexpr int hostile_adj = 2; // Priority bonus for hostile targets
const int iff_dist = ( range + area ) * 3 / 2 + 6; // iff check triggers at this distance
int iff_hangle = 15 + area; // iff safety margin (degrees). less accuracy, more paranoia
float best_target_rating = -1.0f; // bigger is better
int u_angle = 0; // player angle relative to turret
boo_hoo = 0; // how many targets were passed due to IFF. Tragically.
bool self_area_iff = false; // Need to check if the target is near the vehicle we're a part of
bool area_iff = false; // Need to check distance from target to player
bool angle_iff = true; // Need to check if player is in a cone between us and target
int pldist = rl_dist( pos(), g->u.pos() );
vehicle *in_veh = is_fake() ? veh_pointer_or_null( g->m.veh_at( pos() ) ) : nullptr;
if( pldist < iff_dist && sees( g->u ) ) {
area_iff = area > 0;
angle_iff = true;
// Player inside vehicle won't be hit by shots from the roof,
// so we can fire "through" them just fine.
const optional_vpart_position vp = g->m.veh_at( u.pos() );
if( in_veh && veh_pointer_or_null( vp ) == in_veh && vp->is_inside() ) {
angle_iff = false; // No angle IFF, but possibly area IFF
} else if( pldist < 3 ) {
iff_hangle = (pldist == 2 ? 30 : 60); // granularity increases with proximity
}
u_angle = g->m.coord_to_angle(posx(), posy(), u.posx(), u.posy());
}
if( area > 0 && in_veh != nullptr ) {
self_area_iff = true;
}
std::vector<Creature*> targets = g->get_creatures_if( [&]( const Creature &critter ) {
if( const monster *const mon_ptr = dynamic_cast<const monster*>( &critter ) ) {
// friendly to the player, not a target for us
return mon_ptr->friendly == 0;
}
if( const npc *const npc_ptr = dynamic_cast<const npc*>( &critter ) ) {
// friendly to the player, not a target for us
return npc_ptr->get_attitude() == NPCATT_KILL;
}
//@todo: what about g->u?
return false;
} );
for( auto &m : targets ) {
if( !sees( *m ) ) {
// can't see nor sense it
continue;
}
int dist = rl_dist( pos(), m->pos() ) + 1; // rl_dist can be 0
if( dist > range + 1 || dist < area ) {
// Too near or too far
continue;
}
// Prioritize big, armed and hostile stuff
float mon_rating = m->power_rating();
float target_rating = mon_rating / dist;
if( mon_rating + hostile_adj <= 0 ) {
// We wouldn't attack it even if it was hostile
continue;
}
if( in_veh != nullptr && veh_pointer_or_null( g->m.veh_at( m->pos() ) ) == in_veh ) {
// No shooting stuff on vehicle we're a part of
continue;
}
if( area_iff && rl_dist( u.pos(), m->pos() ) <= area ) {
// Player in AoE
boo_hoo++;
continue;
}
// Hostility check can be expensive, but we need to inform the player of boo_hoo
// only when the target is actually "hostile enough"
bool maybe_boo = false;
if( angle_iff ) {
int tangle = g->m.coord_to_angle(posx(), posy(), m->posx(), m->posy());
int diff = abs(u_angle - tangle);
// Player is in the angle and not too far behind the target
if( ( diff + iff_hangle > 360 || diff < iff_hangle ) &&
( dist * 3 / 2 + 6 > pldist ) ) {
maybe_boo = true;
}
}
if( !maybe_boo && ( ( mon_rating + hostile_adj ) / dist <= best_target_rating ) ) {
// "Would we skip the target even if it was hostile?"
// Helps avoid (possibly expensive) attitude calculation
continue;
}
if( m->attitude_to( u ) == A_HOSTILE ) {
target_rating = ( mon_rating + hostile_adj ) / dist;
if( maybe_boo ) {
boo_hoo++;
continue;
}
}
if( target_rating <= best_target_rating || target_rating <= 0 ) {
continue; // Handle this late so that boo_hoo++ can happen
}
// Expensive check for proximity to vehicle
if( self_area_iff && overlaps_vehicle( in_veh->get_points(), m->pos(), area ) ) {
continue;
}
target = m;
best_target_rating = target_rating;
}
return target;
}
// Pick up items at (pos).
void Pickup::pick_up( const tripoint &pos, int min )
{
int cargo_part = -1;
const optional_vpart_position vp = g->m.veh_at( pos );
vehicle *const veh = veh_pointer_or_null( vp );
bool from_vehicle = false;
if( min != -1 ) {
switch( interact_with_vehicle( veh, pos, vp ? vp->part_index() : -1 ) ) {
case DONE:
return;
case ITEMS_FROM_CARGO: {
const cata::optional<vpart_reference> carg = vp.part_with_feature( "CARGO", false );
cargo_part = carg ? carg->part_index() : -1;
}
from_vehicle = cargo_part >= 0;
break;
case ITEMS_FROM_GROUND:
// Nothing to change, default is to pick from ground anyway.
if( g->m.has_flag( "SEALED", pos ) ) {
return;
}
break;
}
}
if( !from_vehicle ) {
bool isEmpty = ( g->m.i_at( pos ).empty() );
// Hide the pickup window if this is a toilet and there's nothing here
// but water.
if( ( !isEmpty ) && g->m.furn( pos ) == f_toilet ) {
isEmpty = true;
for( auto maybe_water : g->m.i_at( pos ) ) {
if( maybe_water.typeId() != "water" ) {
isEmpty = false;
break;
}
}
}
if( isEmpty && ( min != -1 || !get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
return;
}
}
// which items are we grabbing?
std::vector<item> here;
if( from_vehicle ) {
auto vehitems = veh->get_items( cargo_part );
here.resize( vehitems.size() );
std::copy( vehitems.begin(), vehitems.end(), here.begin() );
} else {
auto mapitems = g->m.i_at( pos );
here.resize( mapitems.size() );
std::copy( mapitems.begin(), mapitems.end(), here.begin() );
}
if( min == -1 ) {
// Recursively pick up adjacent items if that option is on.
if( get_option<bool>( "AUTO_PICKUP_ADJACENT" ) && g->u.pos() == pos ) {
//Autopickup adjacent
direction adjacentDir[8] = {NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST};
for( auto &elem : adjacentDir ) {
tripoint apos = tripoint( direction_XY( elem ), 0 );
apos += pos;
pick_up( apos, min );
}
}
// Bail out if this square cannot be auto-picked-up
if( g->check_zone( zone_type_id( "NO_AUTO_PICKUP" ), pos ) ) {
return;
} else if( g->m.has_flag( "SEALED", pos ) ) {
return;
}
}
// Not many items, just grab them
if( ( int )here.size() <= min && min != -1 ) {
g->u.assign_activity( activity_id( "ACT_PICKUP" ) );
g->u.activity.placement = pos - g->u.pos();
g->u.activity.values.push_back( from_vehicle );
// Only one item means index is 0.
g->u.activity.values.push_back( 0 );
// auto-pickup means pick up all.
g->u.activity.values.push_back( 0 );
return;
}
std::vector<std::list<item_idx>> stacked_here;
for( size_t i = 0; i < here.size(); i++ ) {
item &it = here[i];
bool found_stack = false;
for( auto &stack : stacked_here ) {
if( stack.begin()->_item.stacks_with( it ) ) {
item_idx el = { it, i };
stack.push_back( el );
found_stack = true;
break;
}
}
if( !found_stack ) {
std::list<item_idx> newstack;
newstack.push_back( { it, i } );
stacked_here.push_back( newstack );
}
}
std::reverse( stacked_here.begin(), stacked_here.end() );
if( min != -1 ) { // don't bother if we're just autopickuping
g->temp_exit_fullscreen();
}
bool sideStyle = use_narrow_sidebar();
// Otherwise, we have Autopickup, 2 or more items and should list them, etc.
int maxmaxitems = sideStyle ? TERMY : getmaxy( g->w_messages ) - 3;
int itemsH = std::min( 25, TERMY / 2 );
int pickupBorderRows = 3;
// The pickup list may consume the entire terminal, minus space needed for its
// header/footer and the item info window.
int minleftover = itemsH + pickupBorderRows;
if( maxmaxitems > TERMY - minleftover ) {
maxmaxitems = TERMY - minleftover;
}
const int minmaxitems = sideStyle ? 6 : 9;
std::vector<pickup_count> getitem( stacked_here.size() );
int maxitems = stacked_here.size();
maxitems = ( maxitems < minmaxitems ? minmaxitems : ( maxitems > maxmaxitems ? maxmaxitems :
maxitems ) );
int itemcount = 0;
if( min == -1 ) { //Auto Pickup, select matching items
if( !select_autopickup_items( stacked_here, getitem ) ) {
// If we didn't find anything, bail out now.
return;
}
} else {
int pickupH = maxitems + pickupBorderRows;
int pickupW = getmaxx( g->w_messages );
int pickupY = VIEW_OFFSET_Y;
int pickupX = getbegx( g->w_messages );
int itemsW = pickupW;
int itemsY = sideStyle ? pickupY + pickupH : TERMY - itemsH;
int itemsX = pickupX;
catacurses::window w_pickup = catacurses::newwin( pickupH, pickupW, pickupY, pickupX );
catacurses::window w_item_info = catacurses::newwin( itemsH, itemsW, itemsY, itemsX );
std::string action;
long raw_input_char = ' ';
input_context ctxt( "PICKUP" );
ctxt.register_action( "UP" );
ctxt.register_action( "DOWN" );
ctxt.register_action( "RIGHT" );
ctxt.register_action( "LEFT" );
ctxt.register_action( "NEXT_TAB", _( "Next page" ) );
ctxt.register_action( "PREV_TAB", _( "Previous page" ) );
ctxt.register_action( "SCROLL_UP" );
ctxt.register_action( "SCROLL_DOWN" );
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "SELECT_ALL" );
ctxt.register_action( "QUIT", _( "Cancel" ) );
ctxt.register_action( "ANY_INPUT" );
ctxt.register_action( "HELP_KEYBINDINGS" );
ctxt.register_action( "FILTER" );
int start = 0;
int cur_it = 0;
bool update = true;
mvwprintw( w_pickup, 0, 0, _( "PICK UP" ) );
int selected = 0;
int iScrollPos = 0;
std::string filter;
std::string new_filter;
std::vector<int> matches;//Indexes of items that match the filter
bool filter_changed = true;
if( g->was_fullscreen ) {
g->draw_ter();
}
// Now print the two lists; those on the ground and about to be added to inv
// Continue until we hit return or space
do {
const std::string pickup_chars =
ctxt.get_available_single_char_hotkeys( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:;" );
int idx = -1;
for( int i = 1; i < pickupH; i++ ) {
mvwprintw( w_pickup, i, 0,
" " );
}
if( action == "ANY_INPUT" &&
raw_input_char >= '0' && raw_input_char <= '9' ) {
int raw_input_char_value = ( char )raw_input_char - '0';
itemcount *= 10;
itemcount += raw_input_char_value;
if( itemcount < 0 ) {
itemcount = 0;
}
} else if( action == "SCROLL_UP" ) {
iScrollPos--;
} else if( action == "SCROLL_DOWN" ) {
iScrollPos++;
} else if( action == "PREV_TAB" ) {
if( start > 0 ) {
start -= maxitems;
} else {
start = ( int )( ( matches.size() - 1 ) / maxitems ) * maxitems;
}
selected = start;
mvwprintw( w_pickup, maxitems + 2, 0, " " );
} else if( action == "NEXT_TAB" ) {
if( start + maxitems < ( int )matches.size() ) {
start += maxitems;
} else {
start = 0;
}
iScrollPos = 0;
selected = start;
mvwprintw( w_pickup, maxitems + 2, pickupH, " " );
} else if( action == "UP" ) {
selected--;
iScrollPos = 0;
if( selected < 0 ) {
selected = matches.size() - 1;
start = ( int )( matches.size() / maxitems ) * maxitems;
if( start >= ( int )matches.size() ) {
start -= maxitems;
}
} else if( selected < start ) {
start -= maxitems;
}
} else if( action == "DOWN" ) {
selected++;
iScrollPos = 0;
if( selected >= ( int )matches.size() ) {
selected = 0;
start = 0;
} else if( selected >= start + maxitems ) {
start += maxitems;
}
} else if( selected >= 0 && selected < int( matches.size() ) &&
( ( action == "RIGHT" && !getitem[matches[selected]].pick ) ||
( action == "LEFT" && getitem[matches[selected]].pick ) ) ) {
idx = selected;
} else if( action == "FILTER" ) {
new_filter = filter;
string_input_popup popup;
popup
.title( _( "Set filter" ) )
.width( 30 )
.edit( new_filter );
if( !popup.canceled() ) {
filter_changed = true;
} else {
wrefresh( g->w_terrain );
}
} else if( action == "ANY_INPUT" && raw_input_char == '`' ) {
std::string ext = string_input_popup()
.title( _( "Enter 2 letters (case sensitive):" ) )
.width( 3 )
.max_length( 2 )
.query_string();
if( ext.size() == 2 ) {
int p1 = pickup_chars.find( ext.at( 0 ) );
int p2 = pickup_chars.find( ext.at( 1 ) );
if( p1 != -1 && p2 != -1 ) {
idx = pickup_chars.size() + ( p1 * pickup_chars.size() ) + p2;
}
}
} else if( action == "ANY_INPUT" ) {
idx = ( raw_input_char <= 127 ) ? pickup_chars.find( raw_input_char ) : -1;
iScrollPos = 0;
}
if( idx >= 0 && idx < ( int )matches.size() ) {
size_t true_idx = matches[idx];
if( itemcount != 0 || getitem[true_idx].count == 0 ) {
item &temp = stacked_here[true_idx].begin()->_item;
int amount_available = temp.count_by_charges() ? temp.charges : stacked_here[true_idx].size();
if( itemcount >= amount_available ) {
itemcount = 0;
}
getitem[true_idx].count = itemcount;
itemcount = 0;
}
// Note: this might not change the value of getitem[idx] at all!
getitem[true_idx].pick = ( action == "RIGHT" ? true :
( action == "LEFT" ? false :
!getitem[true_idx].pick ) );
if( action != "RIGHT" && action != "LEFT" ) {
selected = idx;
start = ( int )( idx / maxitems ) * maxitems;
}
if( !getitem[true_idx].pick ) {
getitem[true_idx].count = 0;
}
update = true;
}
if( filter_changed ) {
matches.clear();
while( matches.empty() ) {
auto filter_func = item_filter_from_string( new_filter );
for( size_t index = 0; index < stacked_here.size(); index++ ) {
if( filter_func( stacked_here[index].begin()->_item ) ) {
matches.push_back( index );
}
}
if( matches.empty() ) {
popup( _( "Your filter returned no results" ) );
wrefresh( g->w_terrain );
// The filter must have results, or simply be emptied or canceled,
// as this screen can't be reached without there being
// items available
string_input_popup popup;
popup
.title( _( "Set filter" ) )
.width( 30 )
.edit( new_filter );
if( popup.canceled() ) {
new_filter = filter;
filter_changed = false;
}
}
}
if( filter_changed ) {
filter = new_filter;
filter_changed = false;
selected = 0;
start = 0;
iScrollPos = 0;
}
wrefresh( g->w_terrain );
}
item &selected_item = stacked_here[matches[selected]].begin()->_item;
werase( w_item_info );
if( selected >= 0 && selected <= ( int )stacked_here.size() - 1 ) {
std::vector<iteminfo> vThisItem;
std::vector<iteminfo> vDummy;
selected_item.info( true, vThisItem );
draw_item_info( w_item_info, "", "", vThisItem, vDummy, iScrollPos, true, true );
}
draw_custom_border( w_item_info, false );
mvwprintw( w_item_info, 0, 2, "< " );
trim_and_print( w_item_info, 0, 4, itemsW - 8, c_white, "%s >",
selected_item.display_name().c_str() );
wrefresh( w_item_info );
if( action == "SELECT_ALL" ) {
int count = 0;
for( auto i : matches ) {
if( getitem[i].pick ) {
count++;
}
getitem[i].pick = true;
}
if( count == ( int )stacked_here.size() ) {
for( size_t i = 0; i < stacked_here.size(); i++ ) {
getitem[i].pick = false;
}
}
update = true;
}
for( cur_it = start; cur_it < start + maxitems; cur_it++ ) {
mvwprintw( w_pickup, 1 + ( cur_it % maxitems ), 0,
" " );
if( cur_it < ( int )matches.size() ) {
int true_it = matches[cur_it];
item &this_item = stacked_here[ true_it ].begin()->_item;
nc_color icolor = this_item.color_in_inventory();
if( cur_it == selected ) {
icolor = hilite( icolor );
}
if( cur_it < ( int )pickup_chars.size() ) {
mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor,
char( pickup_chars[cur_it] ) );
} else if( cur_it < ( int )pickup_chars.size() + ( int )pickup_chars.size() *
( int )pickup_chars.size() ) {
int p = cur_it - pickup_chars.size();
int p1 = p / pickup_chars.size();
int p2 = p % pickup_chars.size();
mvwprintz( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, "`%c%c",
char( pickup_chars[p1] ), char( pickup_chars[p2] ) );
} else {
mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, ' ' );
}
if( getitem[true_it].pick ) {
if( getitem[true_it].count == 0 ) {
wprintz( w_pickup, c_light_blue, " + " );
} else {
wprintz( w_pickup, c_light_blue, " # " );
}
} else {
wprintw( w_pickup, " - " );
}
std::string item_name;
if( stacked_here[true_it].begin()->_item.ammo_type() == "money" ) {
//Count charges
//TODO: transition to the item_location system used for the inventory
unsigned long charges_total = 0;
for( const auto item : stacked_here[true_it] ) {
charges_total += item._item.charges;
}
//Picking up none or all the cards in a stack
if( !getitem[true_it].pick || getitem[true_it].count == 0 ) {
item_name = stacked_here[true_it].begin()->_item.display_money( stacked_here[true_it].size(),
charges_total );
} else {
unsigned long charges = 0;
int c = getitem[true_it].count;
for( auto it = stacked_here[true_it].begin(); it != stacked_here[true_it].end() &&
c > 0; ++it, --c ) {
charges += it->_item.charges;
}
item_name = string_format( _( "%s of %s" ),
stacked_here[true_it].begin()->_item.display_money( getitem[true_it].count, charges ),
format_money( charges_total ) );
}
} else {
item_name = this_item.display_name( stacked_here[true_it].size() );
}
if( stacked_here[true_it].size() > 1 ) {
item_name = string_format( "%d %s", stacked_here[true_it].size(), item_name.c_str() );
}
if( get_option<bool>( "ITEM_SYMBOLS" ) ) {
item_name = string_format( "%s %s", this_item.symbol().c_str(),
item_name.c_str() );
}
trim_and_print( w_pickup, 1 + ( cur_it % maxitems ), 6, pickupW - 4, icolor,
item_name );
}
}
mvwprintw( w_pickup, maxitems + 1, 0, _( "[%s] Unmark" ),
ctxt.get_desc( "LEFT", 1 ).c_str() );
center_print( w_pickup, maxitems + 1, c_light_gray, string_format( _( "[%s] Help" ),
ctxt.get_desc( "HELP_KEYBINDINGS", 1 ).c_str() ) );
right_print( w_pickup, maxitems + 1, 0, c_light_gray, string_format( _( "[%s] Mark" ),
ctxt.get_desc( "RIGHT", 1 ).c_str() ) );
mvwprintw( w_pickup, maxitems + 2, 0, _( "[%s] Prev" ),
ctxt.get_desc( "PREV_TAB", 1 ).c_str() );
center_print( w_pickup, maxitems + 2, c_light_gray, string_format( _( "[%s] All" ),
ctxt.get_desc( "SELECT_ALL", 1 ).c_str() ) );
right_print( w_pickup, maxitems + 2, 0, c_light_gray, string_format( _( "[%s] Next" ),
ctxt.get_desc( "NEXT_TAB", 1 ).c_str() ) );
if( update ) { // Update weight & volume information
update = false;
for( int i = 9; i < pickupW; ++i ) {
mvwaddch( w_pickup, 0, i, ' ' );
}
units::mass weight_picked_up = 0;
units::volume volume_picked_up = 0;
for( size_t i = 0; i < getitem.size(); i++ ) {
if( getitem[i].pick ) {
item temp = stacked_here[i].begin()->_item;
if( temp.count_by_charges() && getitem[i].count < temp.charges && getitem[i].count != 0 ) {
temp.charges = getitem[i].count;
}
int num_picked = std::min( stacked_here[i].size(),
getitem[i].count == 0 ? stacked_here[i].size() : getitem[i].count );
weight_picked_up += temp.weight() * num_picked;
volume_picked_up += temp.volume() * num_picked;
}
}
auto weight_predict = g->u.weight_carried() + weight_picked_up;
auto volume_predict = g->u.volume_carried() + volume_picked_up;
mvwprintz( w_pickup, 0, 9, weight_predict > g->u.weight_capacity() ? c_red : c_white,
_( "Wgt %.1f" ), round_up( convert_weight( weight_predict ), 1 ) );
wprintz( w_pickup, c_white, "/%.1f", round_up( convert_weight( g->u.weight_capacity() ), 1 ) );
std::string fmted_volume_predict = format_volume( volume_predict );
mvwprintz( w_pickup, 0, 24, volume_predict > g->u.volume_capacity() ? c_red : c_white,
_( "Vol %s" ), fmted_volume_predict.c_str() );
std::string fmted_volume_capacity = format_volume( g->u.volume_capacity() );
wprintz( w_pickup, c_white, "/%s", fmted_volume_capacity.c_str() );
};
wrefresh( w_pickup );
action = ctxt.handle_input();
raw_input_char = ctxt.get_raw_input().get_first_input();
} while( action != "QUIT" && action != "CONFIRM" );
bool item_selected = false;
// Check if we have selected an item.
for( auto selection : getitem ) {
if( selection.pick ) {
item_selected = true;
}
}
if( action != "CONFIRM" || !item_selected ) {
w_pickup = catacurses::window();
w_item_info = catacurses::window();
add_msg( _( "Never mind." ) );
g->reenter_fullscreen();
g->refresh_all();
return;
}
}
// At this point we've selected our items, register an activity to pick them up.
g->u.assign_activity( activity_id( "ACT_PICKUP" ) );
g->u.activity.placement = pos - g->u.pos();
g->u.activity.values.push_back( from_vehicle );
if( min == -1 ) {
// Auto pickup will need to auto resume since there can be several of them on the stack.
g->u.activity.auto_resume = true;
}
std::vector<std::pair<int, int>> pick_values;
for( size_t i = 0; i < stacked_here.size(); i++ ) {
const auto &selection = getitem[i];
if( !selection.pick ) {
continue;
}
const auto &stack = stacked_here[i];
// Note: items can be both charged and stacked
// For robustness, let's assume they can be both in the same stack
bool pick_all = selection.count == 0;
size_t count = selection.count;
for( const item_idx &it : stack ) {
if( !pick_all && count == 0 ) {
break;
}
if( it._item.count_by_charges() ) {
size_t num_picked = std::min( ( size_t )it._item.charges, count );
pick_values.push_back( { static_cast<int>( it.idx ), static_cast<int>( num_picked ) } );
count -= num_picked;
} else {
size_t num_picked = 1;
pick_values.push_back( { static_cast<int>( it.idx ), 0 } );
count -= num_picked;
}
}
}
// The pickup activity picks up items last-to-first from its values list, so make sure the
// higher indices are at the end.
std::sort( pick_values.begin(), pick_values.end() );
for( auto &it : pick_values ) {
g->u.activity.values.push_back( it.first );
g->u.activity.values.push_back( it.second );
}
g->reenter_fullscreen();
}
bool game::grabbed_veh_move( const tripoint &dp )
{
const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
if( !grabbed_vehicle_vp ) {
add_msg( m_info, _( "No vehicle at grabbed point." ) );
u.grab( OBJECT_NONE );
return false;
}
vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
const int grabbed_part = grabbed_vehicle_vp->part_index();
const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
if( grabbed_vehicle == veh_under_player ) {
u.grab_point = -dp;
return false;
}
tripoint dp_veh = -u.grab_point;
const tripoint prev_grab = u.grab_point;
tripoint next_grab = u.grab_point;
bool zigzag = false;
if( dp == prev_grab ) {
// We are pushing in the direction of vehicle
dp_veh = dp;
} else if( abs( dp.x + dp_veh.x ) != 2 && abs( dp.y + dp_veh.y ) != 2 ) {
// Not actually moving the vehicle, don't do the checks
u.grab_point = -( dp + dp_veh );
return false;
} else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
next_grab.x != 0 && next_grab.y != 0 ) {
// Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
// and moves away from it, but not directly away
dp_veh.x = ( dp.x == -dp_veh.x ) ? 0 : dp_veh.x;
dp_veh.y = ( dp.y == -dp_veh.y ) ? 0 : dp_veh.y;
next_grab = -dp_veh;
zigzag = true;
} else {
// We are pulling the vehicle
next_grab = -dp;
}
// Make sure the mass and pivot point are correct
grabbed_vehicle->invalidate_mass();
//vehicle movement: strength check
int mc = 0;
int str_req = ( grabbed_vehicle->total_mass() / 25_kilogram ); //strength required to move vehicle.
//if vehicle is rollable we modify str_req based on a function of movecost per wheel.
// Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
// (Roughly 1.1K kg = danger zone; cube vans are about the max)
if( str_req > 45 ) {
add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
grabbed_vehicle->name );
return true; // No shoving around an RV.
}
const auto &wheel_indices = grabbed_vehicle->wheelcache;
if( grabbed_vehicle->valid_wheel_config() ) {
//determine movecost for terrain touching wheels
const tripoint vehpos = grabbed_vehicle->global_pos3();
for( int p : wheel_indices ) {
const tripoint wheel_pos = vehpos + grabbed_vehicle->parts[p].precalc[0];
const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
mc += ( str_req / wheel_indices.size() ) * mapcost;
}
//set strength check threshold
//if vehicle has many or only one wheel (shopping cart), it is as if it had four.
if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
str_req = mc / 4 + 1;
} else {
str_req = mc / wheel_indices.size() + 1;
}
} else {
str_req++;
//if vehicle has no wheels str_req make a noise.
if( str_req <= u.get_str() ) {
sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
_( "a scraping noise." ), true, "misc", "scraping" );
}
}
//final strength check and outcomes
///\EFFECT_STR determines ability to drag vehicles
if( str_req <= u.get_str() ) {
//calculate exertion factor and movement penalty
///\EFFECT_STR increases speed of dragging vehicles
u.moves -= 100 * str_req / std::max( 1, u.get_str() );
const int ex = dice( 1, 3 ) - 1 + str_req;
if( ex > u.get_str() ) {
add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
u.moves -= 200;
u.mod_pain( 1 );
} else if( ex == u.get_str() ) {
u.moves -= 200;
add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
}
} else {
u.moves -= 100;
add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
return true;
}
std::string blocker_name = _( "errors in movement code" );
const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
tileray mdir;
mdir.init( dir.x, dir.y );
grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
grabbed_vehicle->face = grabbed_vehicle->turn_dir;
grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
// Grabbed part has to stay at distance 1 to the player
// and in roughly the same direction.
const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
grabbed_vehicle->parts[ grabbed_part ].precalc[ 1 ];
const tripoint expected_pos = u.pos() + dp + from;
const tripoint actual_dir = expected_pos - new_part_pos;
// Set player location to illegal value so it can't collide with vehicle.
const tripoint player_prev = u.pos();
u.setpos( tripoint_zero );
std::vector<veh_collision> colls;
const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
u.setpos( player_prev );
if( !colls.empty() ) {
blocker_name = colls.front().target_name;
}
return failed ? tripoint_zero : actual_dir;
};
// First try the move as intended
// But if that fails and the move is a zig-zag, try to recover:
// Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
if( final_dp_veh == tripoint_zero && zigzag ) {
final_dp_veh = get_move_dir( -prev_grab, -dp );
next_grab = -dp;
}
if( final_dp_veh == tripoint_zero ) {
add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
u.grab_point = prev_grab;
return true;
}
u.grab_point = next_grab;
tripoint gp = grabbed_vehicle->global_pos3();
grabbed_vehicle = m.displace_vehicle( gp, final_dp_veh );
if( grabbed_vehicle == nullptr ) {
debugmsg( "Grabbed vehicle disappeared" );
return false;
}
for( int p : wheel_indices ) {
if( one_in( 2 ) ) {
tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
grabbed_vehicle->handle_trap( wheel_p, p );
}
}
return false;
}
void inventory::form_from_map( map &m, const tripoint &origin, int range, bool assign_invlet,
bool clear_path )
{
items.clear();
for( const tripoint &p : m.points_in_radius( origin, range ) ) {
// can not reach this -> can not access its contents
if( clear_path ) {
if( origin != p && !m.clear_path( origin, p, range, 1, 100 ) ) {
continue;
}
}
if( m.has_furn( p ) ) {
const furn_t &f = m.furn( p ).obj();
const itype *type = f.crafting_pseudo_item_type();
if( type != nullptr ) {
const itype *ammo = f.crafting_ammo_item_type();
item furn_item( type, calendar::turn, 0 );
furn_item.item_tags.insert( "PSEUDO" );
furn_item.charges = ammo ? count_charges_in_list( ammo, m.i_at( p ) ) : 0;
add_item( furn_item );
}
}
if( m.accessible_items( p ) ) {
for( auto &i : m.i_at( p ) ) {
if( !i.made_of( LIQUID ) ) {
add_item( i, false, assign_invlet );
}
}
}
// Kludges for now!
if( m.has_nearby_fire( p, 0 ) ) {
item fire( "fire", 0 );
fire.charges = 1;
add_item( fire );
}
// Handle any water from infinite map sources.
item water = m.water_from( p );
if( !water.is_null() ) {
add_item( water );
}
// kludge that can probably be done better to check specifically for toilet water to use in
// crafting
if( m.furn( p ).obj().examine == &iexamine::toilet ) {
// get water charges at location
auto toilet = m.i_at( p );
auto water = toilet.end();
for( auto candidate = toilet.begin(); candidate != toilet.end(); ++candidate ) {
if( candidate->typeId() == "water" ) {
water = candidate;
break;
}
}
if( water != toilet.end() && water->charges > 0 ) {
add_item( *water );
}
}
// keg-kludge
if( m.furn( p ).obj().examine == &iexamine::keg ) {
auto liq_contained = m.i_at( p );
for( auto &i : liq_contained ) {
if( i.made_of( LIQUID ) ) {
add_item( i );
}
}
}
// WARNING: The part below has a bug that's currently quite minor
// When a vehicle has multiple faucets in range, available water is
// multiplied by the number of faucets.
// Same thing happens for all other tools and resources, but not cargo
const optional_vpart_position vp = m.veh_at( p );
if( !vp ) {
continue;
}
vehicle *const veh = &vp->vehicle();
//Adds faucet to kitchen stuff; may be horribly wrong to do such....
//ShouldBreak into own variable
const cata::optional<vpart_reference> kpart = vp.part_with_feature( "KITCHEN", true );
const cata::optional<vpart_reference> faupart = vp.part_with_feature( "FAUCET", true );
const cata::optional<vpart_reference> weldpart = vp.part_with_feature( "WELDRIG", true );
const cata::optional<vpart_reference> craftpart = vp.part_with_feature( "CRAFTRIG", true );
const cata::optional<vpart_reference> forgepart = vp.part_with_feature( "FORGE", true );
const cata::optional<vpart_reference> kilnpart = vp.part_with_feature( "KILN", true );
const cata::optional<vpart_reference> chempart = vp.part_with_feature( "CHEMLAB", true );
const cata::optional<vpart_reference> cargo = vp.part_with_feature( "CARGO", true );
if( cargo ) {
const auto items = veh->get_items( cargo->part_index() );
*this += std::list<item>( items.begin(), items.end() );
}
if( faupart ) {
for( const auto &it : veh->fuels_left() ) {
item fuel( it.first, 0 );
if( fuel.made_of( LIQUID ) ) {
fuel.charges = it.second;
add_item( fuel );
}
}
}
if( kpart ) {
item hotplate( "hotplate", 0 );
hotplate.charges = veh->fuel_left( "battery", true );
hotplate.item_tags.insert( "PSEUDO" );
add_item( hotplate );
item pot( "pot", 0 );
pot.item_tags.insert( "PSEUDO" );
add_item( pot );
item pan( "pan", 0 );
pan.item_tags.insert( "PSEUDO" );
add_item( pan );
}
if( weldpart ) {
item welder( "welder", 0 );
welder.charges = veh->fuel_left( "battery", true );
welder.item_tags.insert( "PSEUDO" );
add_item( welder );
item soldering_iron( "soldering_iron", 0 );
soldering_iron.charges = veh->fuel_left( "battery", true );
soldering_iron.item_tags.insert( "PSEUDO" );
add_item( soldering_iron );
}
if( craftpart ) {
item vac_sealer( "vac_sealer", 0 );
vac_sealer.charges = veh->fuel_left( "battery", true );
vac_sealer.item_tags.insert( "PSEUDO" );
add_item( vac_sealer );
item dehydrator( "dehydrator", 0 );
dehydrator.charges = veh->fuel_left( "battery", true );
dehydrator.item_tags.insert( "PSEUDO" );
add_item( dehydrator );
item food_processor( "food_processor", 0 );
food_processor.charges = veh->fuel_left( "battery", true );
food_processor.item_tags.insert( "PSEUDO" );
add_item( food_processor );
item press( "press", 0 );
press.charges = veh->fuel_left( "battery", true );
press.item_tags.insert( "PSEUDO" );
add_item( press );
}
if( forgepart ) {
item forge( "forge", 0 );
forge.charges = veh->fuel_left( "battery", true );
forge.item_tags.insert( "PSEUDO" );
add_item( forge );
}
if( kilnpart ) {
item kiln( "kiln", 0 );
kiln.charges = veh->fuel_left( "battery", true );
kiln.item_tags.insert( "PSEUDO" );
add_item( kiln );
}
if( chempart ) {
item hotplate( "hotplate", 0 );
hotplate.charges = veh->fuel_left( "battery", true );
hotplate.item_tags.insert( "PSEUDO" );
add_item( hotplate );
item chemistry_set( "chemistry_set", 0 );
chemistry_set.charges = veh->fuel_left( "battery", true );
chemistry_set.item_tags.insert( "PSEUDO" );
add_item( chemistry_set );
}
}
}
