ret_val<edible_rating> player::can_eat( const item &food ) const
{
// @todo This condition occurs way too often. Unify it.
if( is_underwater() ) {
return ret_val<edible_rating>::make_failure( _( "You can't do that while underwater." ) );
}
const auto &comest = food.type->comestible;
if( !comest ) {
return ret_val<edible_rating>::make_failure( _( "That doesn't look edible." ) );
}
const bool eat_verb = food.has_flag( "USE_EAT_VERB" );
const bool edible = eat_verb || comest->comesttype == "FOOD";
const bool drinkable = !eat_verb && comest->comesttype == "DRINK";
if( edible || drinkable ) {
for( const auto &elem : food.type->materials ) {
if( !elem->edible() ) {
return ret_val<edible_rating>::make_failure( _( "That doesn't look edible in its current form." ) );
}
}
}
if( comest->tool != "null" ) {
const bool has = item::count_by_charges( comest->tool )
? has_charges( comest->tool, 1 )
: has_amount( comest->tool, 1 );
if( !has ) {
return ret_val<edible_rating>::make_failure( NO_TOOL,
string_format( _( "You need a %s to consume that!" ),
item::nname( comest->tool ).c_str() ) );
}
}
// For all those folks who loved eating marloss berries. D:< mwuhahaha
if( has_trait( trait_id( "M_DEPENDENT" ) ) && food.typeId() != "mycus_fruit" ) {
return ret_val<edible_rating>::make_failure( INEDIBLE_MUTATION,
_( "We can't eat that. It's not right for us." ) );
}
// Here's why PROBOSCIS is such a negative trait.
if( has_trait( trait_id( "PROBOSCIS" ) ) && !drinkable ) {
return ret_val<edible_rating>::make_failure( INEDIBLE_MUTATION, _( "Ugh, you can't drink that!" ) );
}
if( has_trait( trait_id( "CARNIVORE" ) ) && nutrition_for( food ) > 0 &&
food.has_any_flag( carnivore_blacklist ) && !food.has_flag( "CARNIVORE_OK" ) ) {
return ret_val<edible_rating>::make_failure( INEDIBLE_MUTATION,
_( "Eww. Inedible plant stuff!" ) );
}
if( ( has_trait( trait_id( "HERBIVORE" ) ) || has_trait( trait_id( "RUMINANT" ) ) ) &&
food.has_any_flag( herbivore_blacklist ) ) {
// Like non-cannibal, but more strict!
return ret_val<edible_rating>::make_failure( INEDIBLE_MUTATION,
_( "The thought of eating that makes you feel sick." ) );
}
return ret_val<edible_rating>::make_success();
}
void player_morale::set_worn( const item &it, bool worn )
{
const bool fancy = it.has_flag( "FANCY" );
const bool super_fancy = it.has_flag( "SUPER_FANCY" );
const bool filthy_gear = it.has_flag( "FILTHY" );
const int sign = ( worn ) ? 1 : -1;
const auto update_body_part = [&]( body_part_data & bp_data ) {
if( fancy || super_fancy ) {
bp_data.fancy += sign;
}
if( filthy_gear ) {
bp_data.filthy += sign;
}
bp_data.covered += sign;
};
const auto covered( it.get_covered_body_parts() );
if( covered.any() ) {
for( int i = 0; i < num_bp; ++i ) {
if( covered.test( i ) ) {
update_body_part( body_parts[i] );
}
}
} else {
update_body_part( no_body_part );
}
if( super_fancy ) {
const auto id = it.typeId();
const auto iter = super_fancy_items.find( id );
if( iter != super_fancy_items.end() ) {
iter->second += sign;
if( iter->second == 0 ) {
super_fancy_items.erase( iter );
}
} else if( worn ) {
super_fancy_items[id] = 1;
} else {
debugmsg( "Tried to take off \"%s\" which isn't worn.", id.c_str() );
}
}
if( fancy || super_fancy ) {
update_stylish_bonus();
}
if( filthy_gear ) {
update_squeamish_penalty();
}
update_constrained_penalty();
}
std::pair<int, int> player::fun_for( const item &comest ) const
{
static const trait_id trait_GOURMAND( "GOURMAND" );
static const trait_id trait_SAPROPHAGE( "SAPROPHAGE" );
static const trait_id trait_SAPROVORE( "SAPROVORE" );
static const std::string flag_EATEN_COLD( "EATEN_COLD" );
static const std::string flag_COLD( "COLD" );
if( !comest.is_comestible() ) {
return std::pair<int, int>( 0, 0 );
}
// As float to avoid rounding too many times
float fun = comest.type->comestible->fun;
// Rotten food should be pretty disgusting
const float relative_rot = comest.get_relative_rot();
if( relative_rot > 1.0f && !has_trait( trait_SAPROPHAGE ) && !has_trait( trait_SAPROVORE ) ) {
const float rottedness = clamp( 2 * relative_rot - 2.0f, 0.1f, 1.0f );
// Three effects:
// penalty for rot goes from -2 to -20
// bonus for tasty food drops from 90% to 0%
// disgusting food unfun increases from 110% to 200%
fun -= rottedness * 10;
if( fun > 0 ) {
fun *= ( 1.0f - rottedness );
} else {
fun *= ( 1.0f + rottedness );
}
}
float fun_max = fun < 0 ? fun * 6 : fun * 3;
if( comest.has_flag( flag_EATEN_COLD ) && comest.has_flag( flag_COLD ) ) {
if( fun > 0 ) {
fun *= 3;
} else {
fun = 1;
fun_max = 5;
}
}
if( has_trait( trait_GOURMAND ) ) {
if( fun < -1 ) {
fun_max = fun;
fun /= 2;
} else if( fun > 0 ) {
fun_max = fun_max * 3 / 2;
fun *= 3;
}
}
return std::pair<int, int>( fun, fun_max );
}
bool player::can_consume( const item &it ) const
{
if( can_consume_as_is( it ) ) {
return true;
}
// checking NO_UNLOAD to prevent consumption of `battery` when contained in `battery_car` (#20012)
return !it.is_container_empty() && !it.has_flag( "NO_UNLOAD" ) &&
can_consume_as_is( it.contents.front() );
}
void set_item_food( item &newit )
{
int bday_tmp = newit.bday % 3600; // fuzzy birthday for stacking reasons
newit.bday = int( newit.bday ) + 3600 - bday_tmp;
if( newit.has_flag( "EATEN_HOT" ) ) { // hot foods generated
newit.item_tags.insert( "HOT" );
newit.item_counter = 600;
newit.active = true;
}
}
virtual void select(int entnum, uimenu *menu) {
const int starty = 3;
const int startx = menu->w_width - menu->pad_right;
itype *ity = item_controller->find_template(standard_itype_ids[entnum]);
std::string padding = std::string(menu->pad_right - 1, ' ');
for(int i = 0; i < lastlen + starty + 1; i++ ) {
mvwprintw(menu->window, 1 + i, startx, "%s", padding.c_str() );
}
if ( ity != NULL ) {
tmp.make(item_controller->find_template(standard_itype_ids[entnum]));
tmp.bday = g->turn;
if (tmp.is_tool()) {
tmp.charges = dynamic_cast<it_tool *>(tmp.type)->max_charges;
} else if (tmp.is_ammo()) {
tmp.charges = 100;
} else if (tmp.is_gun()) {
tmp.charges = 0;
} else if (tmp.is_gunmod() && (tmp.has_flag("MODE_AUX") ||
tmp.typeId() == "spare_mag")) {
tmp.charges = 0;
} else {
tmp.charges = -1;
}
if( tmp.is_stationary() ) {
tmp.note = SNIPPET.assign( (dynamic_cast<it_stationary *>(tmp.type))->category );
}
std::vector<std::string> desc = foldstring(tmp.info(true), menu->pad_right - 1);
int dsize = desc.size();
if ( dsize > menu->w_height - 5 ) {
dsize = menu->w_height - 5;
}
lastlen = dsize;
std::string header = string_format("#%d: %s%s",
entnum,
standard_itype_ids[entnum].c_str(),
( incontainer ? " (contained)" : "" )
);
mvwprintz(menu->window, 1, startx + ( menu->pad_right - 1 - header.size() ) / 2, c_cyan, "%s",
header.c_str()
);
for(int i = 0; i < desc.size(); i++ ) {
mvwprintw(menu->window, starty + i, startx, "%s", desc[i].c_str() );
}
mvwprintz(menu->window, menu->w_height - 3, startx, c_green, "%s", msg.c_str());
msg = padding;
mvwprintw(menu->window, menu->w_height - 2, startx, "[/] find, [f] container, [q]uit");
}
}
bool ma_requirements::is_valid_weapon(item& i) {
for (std::set<std::string>::iterator it = req_flags.begin();
it != req_flags.end(); ++it) {
std::string flag = *it;
if (!i.has_flag(flag)) return false;
}
bool valid = i.damage_bash() >= min_bashing_damage
&& i.damage_cut() >= min_cutting_damage;
return valid;
}
bool player::can_feed_furnace_with( const item &it ) const
{
if( !it.flammable() || it.has_flag( "RADIOACTIVE" ) || can_eat( it ).success() ) {
return false;
}
if( !has_active_bionic( bio_furnace ) ) {
return false;
}
return it.typeId() != "corpse"; // @todo Eliminate the hard-coded special case.
}
bool martialart::weapon_valid( const item &it ) const
{
if( it.is_null() ) {
return true;
}
if( has_weapon( it.typeId() ) ) {
return true;
}
return !strictly_unarmed && it.has_flag( "UNARMED_WEAPON" );
}
bool ma_requirements::is_valid_weapon(item &i)
{
for( auto flag : req_flags ) {
if (!i.has_flag(flag)) {
return false;
}
}
bool valid = i.damage_bash() >= min_bashing_damage
&& i.damage_cut() >= min_cutting_damage;
return valid;
}
void player_morale::set_worn( const item &it, bool worn )
{
const bool just_fancy = it.has_flag( "FANCY" );
const bool super_fancy = it.has_flag( "SUPER_FANCY" );
if( just_fancy || super_fancy ) {
const int sign = ( worn ) ? 1 : -1;
for( int i = 0; i < num_bp; i++ ) {
const auto bp = static_cast<body_part>( i );
if( it.covers( bp ) ) {
covered[i] = std::max( covered[i] + sign, 0 );
}
}
if( super_fancy ) {
super_fancy_bonus += 2 * sign;
}
update_stylish_bonus();
}
}
bool ma_requirements::is_valid_weapon( const item &i ) const
{
for( auto flag : req_flags ) {
if (!i.has_flag(flag)) {
return false;
}
}
for( const auto &pr : min_damage ) {
if( i.damage_melee( pr.first ) < pr.second ) {
return false;
}
}
return true;
}
bool Character::i_add_or_drop(item& it, int qty) {
bool retval = true;
bool drop = false;
inv.assign_empty_invlet(it);
for (int i = 0; i < qty; ++i) {
if (!drop && (!can_pickWeight(it.weight(), !OPTIONS["DANGEROUS_PICKUPS"])
|| !can_pickVolume(it.volume()))) {
drop = true;
}
if( drop ) {
retval &= !g->m.add_item_or_charges( pos(), it ).is_null();
} else if ( !( it.has_flag("IRREMOVEABLE") && !it.is_gun() ) ){
i_add(it);
}
}
return retval;
}
// TODO: Move pizza scraping here.
// Same for other kinds of nutrition alterations
// This is used by item display, making actual nutrition available to player.
int player::nutrition_for( const item &comest ) const
{
static const trait_id trait_CARNIVORE( "CARNIVORE" );
static const trait_id trait_GIZZARD( "GIZZARD" );
static const trait_id trait_SAPROPHAGE( "SAPROPHAGE" );
static const std::string flag_CARNIVORE_OK( "CARNIVORE_OK" );
if( !comest.is_comestible() ) {
return 0;
}
// As float to avoid rounding too many times
float nutr = comest.type->comestible->nutr;
if( has_trait( trait_GIZZARD ) ) {
nutr *= 0.6f;
}
if( has_trait( trait_CARNIVORE ) && comest.has_flag( flag_CARNIVORE_OK ) &&
comest.has_any_flag( carnivore_blacklist ) ) {
// TODO: Comment pizza scrapping
nutr *= 0.5f;
}
const float relative_rot = comest.get_relative_rot();
// Saprophages get full nutrition from rotting food
if( relative_rot > 1.0f && !has_trait( trait_SAPROPHAGE ) ) {
// everyone else only gets a portion of the nutrition
// Scaling linearly from 100% at just-rotten to 0 at halfway-rotten-away
const float rottedness = clamp( 2 * relative_rot - 2.0f, 0.1f, 1.0f );
nutr *= ( 1.0f - rottedness );
}
// Bio-digestion gives extra nutrition
if( has_bionic( bio_digestion ) ) {
nutr *= 1.5f;
}
return ( int )nutr;
}
morale_type player::allergy_type( const item &food ) const
{
using allergy_tuple = std::tuple<trait_id, std::string, morale_type>;
static const std::array<allergy_tuple, 8> allergy_tuples = {{
std::make_tuple( trait_id( "VEGETARIAN" ), "ALLERGEN_MEAT", MORALE_VEGETARIAN ),
std::make_tuple( trait_id( "MEATARIAN" ), "ALLERGEN_VEGGY", MORALE_MEATARIAN ),
std::make_tuple( trait_id( "LACTOSE" ), "ALLERGEN_MILK", MORALE_LACTOSE ),
std::make_tuple( trait_id( "ANTIFRUIT" ), "ALLERGEN_FRUIT", MORALE_ANTIFRUIT ),
std::make_tuple( trait_id( "ANTIJUNK" ), "ALLERGEN_JUNK", MORALE_ANTIJUNK ),
std::make_tuple( trait_id( "ANTIWHEAT" ), "ALLERGEN_WHEAT", MORALE_ANTIWHEAT )
}
};
for( const auto &tp : allergy_tuples ) {
if( has_trait( std::get<0>( tp ) ) &&
food.has_flag( std::get<1>( tp ) ) ) {
return std::get<2>( tp );
}
}
return MORALE_NULL;
}
edible_rating player::can_eat( const item &food, bool interactive, bool force ) const
{
if( is_npc() || force ) {
// Just to be sure
interactive = false;
}
const std::string &itname = food.tname();
// Helper to avoid ton of `if( interactive )`
// Prints if interactive is true, does nothing otherwise
const auto maybe_print = [interactive, &itname]
( game_message_type type, const char *str ) {
if( interactive ) {
add_msg( type, str, itname.c_str() );
}
};
// As above, but for queries
// Asks if interactive and not force
// Always true if force
// Never true otherwise
const auto maybe_query = [force, interactive, &itname, this]( const char *str ) {
if( force ) {
return true;
} else if( !interactive ) {
return false;
}
return query_yn( str, itname.c_str() );
};
const auto comest = food.type->comestible.get();
if( comest == nullptr ) {
maybe_print( m_info, _( "That doesn't look edible." ) );
return INEDIBLE;
}
if( comest->tool != "null" ) {
bool has = has_amount( comest->tool, 1 );
if( item::count_by_charges( comest->tool ) ) {
has = has_charges( comest->tool, 1 );
}
if( !has ) {
if( interactive ) {
add_msg_if_player( m_info, _( "You need a %s to consume that!" ),
item::nname( comest->tool ).c_str() );
}
return NO_TOOL;
}
}
if( is_underwater() ) {
maybe_print( m_info, _( "You can't do that while underwater." ) );
return INEDIBLE;
}
// For all those folks who loved eating marloss berries. D:< mwuhahaha
if( has_trait( "M_DEPENDENT" ) && food.type->id != "mycus_fruit" ) {
maybe_print( m_info, _( "We can't eat that. It's not right for us." ) );
return INEDIBLE_MUTATION;
}
const bool drinkable = comest->comesttype == "DRINK" && !food.has_flag( "USE_EAT_VERB" );
// Here's why PROBOSCIS is such a negative trait.
if( has_trait( "PROBOSCIS" ) && !drinkable ) {
maybe_print( m_info, _( "Ugh, you can't drink that!" ) );
return INEDIBLE_MUTATION;
}
int capacity = stomach_capacity();
// TODO: Move this cache to a structure and pass it around
// to speed up checking entire inventory for edibles
const bool gourmand = has_trait( "GOURMAND" );
const bool hibernate = has_active_mutation( "HIBERNATE" );
const bool eathealth = has_trait( "EATHEALTH" );
const bool slimespawner = has_trait( "SLIMESPAWNER" );
const int nutr = nutrition_for( food.type );
const int quench = comest->quench;
bool spoiled = food.rotten();
const int temp_hunger = get_hunger() - nutr;
const int temp_thirst = get_thirst() - quench;
const bool overeating = get_hunger() < 0 && nutr >= 5 && !gourmand && !eathealth && !slimespawner &&
!hibernate;
if( interactive && hibernate &&
( get_hunger() >= -60 && get_thirst() >= -60 ) &&
( temp_hunger < -60 || temp_thirst < -60 ) ) {
if( !maybe_query( _( "You're adequately fueled. Prepare for hibernation?" ) ) ) {
return TOO_FULL;
}
}
const bool carnivore = has_trait( "CARNIVORE" );
if( carnivore && nutr > 0 &&
food.has_any_flag( carnivore_blacklist ) && !food.has_flag( "CARNIVORE_OK" ) ) {
maybe_print( m_info, _( "Eww. Inedible plant stuff!" ) );
return INEDIBLE_MUTATION;
}
if( ( has_trait( "HERBIVORE" ) || has_trait( "RUMINANT" ) ) &&
food.has_any_flag( herbivore_blacklist ) ) {
// Like non-cannibal, but more strict!
maybe_print( m_info, _( "The thought of eating that makes you feel sick. You decide not to." ) );
return INEDIBLE_MUTATION;
}
if( food.has_flag( "CANNIBALISM" ) ) {
if( !has_trait_flag( "CANNIBAL" ) &&
!maybe_query( _( "The thought of eating that makes you feel sick. Really do it?" ) ) ) {
return CANNIBALISM;
}
}
if( is_allergic( food ) &&
!maybe_query( _( "Really eat that %s? Your stomach won't be happy." ) ) ) {
return ALLERGY;
}
if( carnivore && food.has_flag( "ALLERGEN_JUNK" ) && !food.has_flag( "CARNIVORE_OK" ) &&
!maybe_query( _( "Really eat that %s? Your stomach won't be happy." ) ) ) {
return ALLERGY;
}
const bool saprophage = has_trait( "SAPROPHAGE" );
// The item is solid food
const bool chew = comest->comesttype == "FOOD" || food.has_flag( "USE_EAT_VERB" );
if( spoiled ) {
if( !saprophage && !has_trait( "SAPROVORE" ) &&
!maybe_query( _( "This %s smells awful! Eat it?" ) ) ) {
return ROTTEN;
}
} else if( saprophage && chew && !food.has_flag( "FERTILIZER" ) &&
!maybe_query( _( "Really eat that %s? Your stomach won't be happy." ) ) ) {
// Note: We're allowing all non-solid "food". This includes drugs
// Hardcoding fertilizer for now - should be a separate flag later
//~ No, we don't eat "rotten" food. We eat properly aged food, like a normal person.
//~ Semantic difference, but greatly facilitates people being proud of their character.
maybe_print( m_info, _( "It's too fresh, let it age a little first." ) );
return ROTTEN;
}
// Print at most one of those
bool overfull = false;
if( overeating ) {
overfull = !maybe_query( _( "You're full. Force yourself to eat?" ) );
} else if( ( ( nutr > 0 && temp_hunger < capacity ) ||
( comest->quench > 0 && temp_thirst < capacity ) ) &&
!eathealth && !slimespawner ) {
overfull = !maybe_query( _( "You will not be able to finish it all. Consume it?" ) );
}
if( overfull ) {
return TOO_FULL;
}
// All checks ended, it's edible (or we're pretending it is)
return EDIBLE;
}
zone_type_id zone_manager::get_near_zone_type_for_item( const item &it,
const tripoint &where ) const
{
auto cat = it.get_category();
if( it.has_flag( "FIREWOOD" ) ) {
if( has_near( zone_type_id( "LOOT_WOOD" ), where ) ) {
return zone_type_id( "LOOT_WOOD" );
}
}
if( cat.id() == "food" ) {
const bool preserves = it.is_food_container() && it.type->container->preserves;
const auto &it_food = it.is_food_container() ? it.contents.front() : it;
if( it_food.is_food() ) { // skip food without comestible, like MREs
if( it_food.get_comestible()->comesttype == "DRINK" ) {
if( !preserves && it_food.goes_bad() && has_near( zone_type_id( "LOOT_PDRINK" ), where ) ) {
return zone_type_id( "LOOT_PDRINK" );
} else if( has_near( zone_type_id( "LOOT_DRINK" ), where ) ) {
return zone_type_id( "LOOT_DRINK" );
}
}
if( !preserves && it_food.goes_bad() && has_near( zone_type_id( "LOOT_PFOOD" ), where ) ) {
return zone_type_id( "LOOT_PFOOD" );
}
}
return zone_type_id( "LOOT_FOOD" );
}
if( cat.id() == "guns" ) {
return zone_type_id( "LOOT_GUNS" );
}
if( cat.id() == "magazines" ) {
return zone_type_id( "LOOT_MAGAZINES" );
}
if( cat.id() == "ammo" ) {
return zone_type_id( "LOOT_AMMO" );
}
if( cat.id() == "weapons" ) {
return zone_type_id( "LOOT_WEAPONS" );
}
if( cat.id() == "tools" ) {
return zone_type_id( "LOOT_TOOLS" );
}
if( cat.id() == "clothing" ) {
if( it.is_filthy() && has_near( zone_type_id( "LOOT_FCLOTHING" ), where ) ) {
return zone_type_id( "LOOT_FCLOTHING" );
}
return zone_type_id( "LOOT_CLOTHING" );
}
if( cat.id() == "drugs" ) {
return zone_type_id( "LOOT_DRUGS" );
}
if( cat.id() == "books" ) {
return zone_type_id( "LOOT_BOOKS" );
}
if( cat.id() == "mods" ) {
return zone_type_id( "LOOT_MODS" );
}
if( cat.id() == "mutagen" ) {
return zone_type_id( "LOOT_MUTAGENS" );
}
if( cat.id() == "bionics" ) {
return zone_type_id( "LOOT_BIONICS" );
}
if( cat.id() == "veh_parts" ) {
return zone_type_id( "LOOT_VEHICLE_PARTS" );
}
if( cat.id() == "other" ) {
return zone_type_id( "LOOT_OTHER" );
}
if( cat.id() == "fuel" ) {
return zone_type_id( "LOOT_FUEL" );
}
if( cat.id() == "seeds" ) {
return zone_type_id( "LOOT_SEEDS" );
}
if( cat.id() == "chems" ) {
return zone_type_id( "LOOT_CHEMICAL" );
}
if( cat.id() == "spare_parts" ) {
return zone_type_id( "LOOT_SPARE_PARTS" );
}
if( cat.id() == "artifacts" ) {
return zone_type_id( "LOOT_ARTIFACTS" );
}
if( cat.id() == "armor" ) {
if( it.is_filthy() && has_near( zone_type_id( "LOOT_FARMOR" ), where ) ) {
return zone_type_id( "LOOT_FARMOR" );
}
return zone_type_id( "LOOT_ARMOR" );
}
return zone_type_id();
}
ret_val<edible_rating> player::will_eat( const item &food, bool interactive ) const
{
const auto ret = can_eat( food );
if( !ret.success() ) {
if( interactive ) {
add_msg_if_player( m_info, "%s", ret.c_str() );
}
return ret;
}
std::vector<ret_val<edible_rating>> consequences;
const auto add_consequence = [&consequences]( const std::string & msg, edible_rating code ) {
consequences.emplace_back( ret_val<edible_rating>::make_failure( code, msg ) );
};
const bool saprophage = has_trait( trait_id( "SAPROPHAGE" ) );
const auto &comest = food.type->comestible;
if( food.rotten() ) {
const bool saprovore = has_trait( trait_id( "SAPROVORE" ) );
if( !saprophage && !saprovore ) {
add_consequence( _( "This is rotten and smells awful!" ), ROTTEN );
}
}
const bool carnivore = has_trait( trait_id( "CARNIVORE" ) );
if( food.has_flag( "CANNIBALISM" ) && !has_trait_flag( "CANNIBAL" ) ) {
add_consequence( _( "The thought of eating human flesh makes you feel sick." ), CANNIBALISM );
}
const bool edible = comest->comesttype == "FOOD" || food.has_flag( "USE_EAT_VERB" );
if( edible && has_effect( effect_nausea ) ) {
add_consequence( _( "You still feel nauseous and will probably puke it all up again." ), NAUSEA );
}
if( ( allergy_type( food ) != MORALE_NULL ) || ( carnivore && food.has_flag( "ALLERGEN_JUNK" ) &&
!food.has_flag( "CARNIVORE_OK" ) ) ) {
add_consequence( _( "Your stomach won't be happy (allergy)." ), ALLERGY );
}
if( saprophage && edible && food.rotten() && !food.has_flag( "FERTILIZER" ) ) {
// Note: We're allowing all non-solid "food". This includes drugs
// Hard-coding fertilizer for now - should be a separate flag later
//~ No, we don't eat "rotten" food. We eat properly aged food, like a normal person.
//~ Semantic difference, but greatly facilitates people being proud of their character.
add_consequence( _( "Your stomach won't be happy (not rotten enough)." ), ALLERGY_WEAK );
}
const int nutr = nutrition_for( food );
const int quench = comest->quench;
const int temp_hunger = get_hunger() - nutr;
const int temp_thirst = get_thirst() - quench;
if( !has_active_mutation( trait_id( "EATHEALTH" ) ) &&
!has_active_mutation( trait_id( "HIBERNATE" ) ) &&
!has_trait( trait_id( "SLIMESPAWNER" ) ) ) {
if( get_hunger() < 0 && nutr >= 5 && !has_active_mutation( trait_id( "GOURMAND" ) ) ) {
add_consequence( _( "You're full already and will be forcing yourself to eat." ), TOO_FULL );
} else if( ( ( nutr > 0 && temp_hunger < stomach_capacity() ) ||
( comest->quench > 0 && temp_thirst < stomach_capacity() ) ) &&
!food.has_infinite_charges() ) {
add_consequence( _( "You will not be able to finish it all." ), TOO_FULL );
}
}
if( !consequences.empty() ) {
if( !interactive ) {
return consequences.front();
}
std::ostringstream req;
for( const auto &elem : consequences ) {
req << elem.str() << std::endl;
}
const bool eat_verb = food.has_flag( "USE_EAT_VERB" );
if( eat_verb || comest->comesttype == "FOOD" ) {
req << string_format( _( "Eat your %s anyway?" ), food.tname().c_str() );
} else if( !eat_verb && comest->comesttype == "DRINK" ) {
req << string_format( _( "Drink your %s anyway?" ), food.tname().c_str() );
} else {
req << string_format( _( "Consume your %s anyway?" ), food.tname().c_str() );
}
if( !query_yn( req.str() ) ) {
return consequences.front();
}
}
// All checks ended, it's edible (or we're pretending it is)
return ret_val<edible_rating>::make_success();
}
bool player::eat( item &food, bool force )
{
if( !food.is_food() ) {
return false;
}
// Check if it's rotten before eating!
food.calc_rot( global_square_location() );
const auto ret = force ? can_eat( food ) : will_eat( food, is_player() );
if( !ret.success() ) {
return false;
}
if( food.type->has_use() ) {
if( food.type->invoke( *this, food, pos() ) <= 0 ) {
return false;
}
}
// Note: the block below assumes we decided to eat it
// No coming back from here
const bool hibernate = has_active_mutation( trait_id( "HIBERNATE" ) );
const int nutr = nutrition_for( food );
const int quench = food.type->comestible->quench;
const bool spoiled = food.rotten();
// The item is solid food
const bool chew = food.type->comestible->comesttype == "FOOD" || food.has_flag( "USE_EAT_VERB" );
// This item is a drink and not a solid food (and not a thick soup)
const bool drinkable = !chew && food.type->comestible->comesttype == "DRINK";
// If neither of the above is true then it's a drug and shouldn't get mealtime penalty/bonus
if( hibernate &&
( get_hunger() > -60 && get_thirst() > -60 ) &&
( get_hunger() - nutr < -60 || get_thirst() - quench < -60 ) ) {
add_memorial_log( pgettext( "memorial_male", "Began preparing for hibernation." ),
pgettext( "memorial_female", "Began preparing for hibernation." ) );
add_msg_if_player(
_( "You've begun stockpiling calories and liquid for hibernation. You get the feeling that you should prepare for bed, just in case, but...you're hungry again, and you could eat a whole week's worth of food RIGHT NOW." ) );
}
const bool will_vomit = get_hunger() < 0 && nutr >= 5 && !has_trait( trait_id( "GOURMAND" ) ) &&
!hibernate &&
!has_trait( trait_id( "SLIMESPAWNER" ) ) && !has_trait( trait_id( "EATHEALTH" ) ) &&
rng( -200, 0 ) > get_hunger() - nutr;
const bool saprophage = has_trait( trait_id( "SAPROPHAGE" ) );
if( spoiled && !saprophage ) {
add_msg_if_player( m_bad, _( "Ick, this %s doesn't taste so good..." ), food.tname().c_str() );
if( !has_trait( trait_id( "SAPROVORE" ) ) && !has_trait( trait_id( "EATDEAD" ) ) &&
( !has_bionic( bio_digestion ) || one_in( 3 ) ) ) {
add_effect( effect_foodpoison, rng( 60, ( nutr + 1 ) * 60 ) );
}
consume_effects( food );
} else if( spoiled && saprophage ) {
add_msg_if_player( m_good, _( "Mmm, this %s tastes delicious..." ), food.tname().c_str() );
consume_effects( food );
} else {
consume_effects( food );
}
const bool amorphous = has_trait( trait_id( "AMORPHOUS" ) );
int mealtime = 250;
if( drinkable || chew ) {
// Those bonuses/penalties only apply to food
// Not to smoking weed or applying bandages!
if( has_trait( trait_id( "MOUTH_TENTACLES" ) ) || has_trait( trait_id( "MANDIBLES" ) ) ) {
mealtime /= 2;
} else if( has_trait( trait_id( "GOURMAND" ) ) ) {
// Don't stack those two - that would be 25 moves per item
mealtime -= 100;
}
if( has_trait( trait_id( "BEAK_HUM" ) ) && !drinkable ) {
mealtime += 200; // Much better than PROBOSCIS but still optimized for fluids
} else if( has_trait( trait_id( "SABER_TEETH" ) ) ) {
mealtime += 250; // They get In The Way
}
if( amorphous ) {
mealtime *= 1.1;
// Minor speed penalty for having to flow around it
// rather than just grab & munch
}
}
moves -= mealtime;
// If it's poisonous... poison us.
// TODO: Move this to a flag
if( food.poison > 0 && !has_trait( trait_id( "EATPOISON" ) ) &&
!has_trait( trait_id( "EATDEAD" ) ) ) {
if( food.poison >= rng( 2, 4 ) ) {
add_effect( effect_poison, food.poison * 100 );
}
add_effect( effect_foodpoison, food.poison * 300 );
}
if( amorphous ) {
add_msg_player_or_npc( _( "You assimilate your %s." ), _( "<npcname> assimilates a %s." ),
food.tname().c_str() );
} else if( drinkable ) {
add_msg_player_or_npc( _( "You drink your %s." ), _( "<npcname> drinks a %s." ),
food.tname().c_str() );
} else if( chew ) {
add_msg_player_or_npc( _( "You eat your %s." ), _( "<npcname> eats a %s." ),
food.tname().c_str() );
}
if( item::find_type( food.type->comestible->tool )->tool ) {
// Tools like lighters get used
use_charges( food.type->comestible->tool, 1 );
}
if( has_bionic( bio_ethanol ) && food.type->can_use( "ALCOHOL" ) ) {
charge_power( rng( 50, 200 ) );
}
if( has_bionic( bio_ethanol ) && food.type->can_use( "ALCOHOL_WEAK" ) ) {
charge_power( rng( 25, 100 ) );
}
if( has_bionic( bio_ethanol ) && food.type->can_use( "ALCOHOL_STRONG" ) ) {
charge_power( rng( 75, 300 ) );
}
if( food.has_flag( "CANNIBALISM" ) ) {
// Sapiovores don't recognize humans as the same species.
// But let them possibly feel cool about eating sapient stuff - treat like psycho
const bool cannibal = has_trait( trait_id( "CANNIBAL" ) );
const bool psycho = has_trait( trait_id( "PSYCHOPATH" ) ) || has_trait( trait_id( "SAPIOVORE" ) );
const bool spiritual = has_trait( trait_id( "SPIRITUAL" ) );
if( cannibal && psycho && spiritual ) {
add_msg_if_player( m_good,
_( "You feast upon the human flesh, and in doing so, devour their spirit." ) );
// You're not really consuming anything special; you just think you are.
add_morale( MORALE_CANNIBAL, 25, 300 );
} else if( cannibal && psycho ) {
add_msg_if_player( m_good, _( "You feast upon the human flesh." ) );
add_morale( MORALE_CANNIBAL, 15, 200 );
} else if( cannibal && spiritual ) {
add_msg_if_player( m_good, _( "You consume the sacred human flesh." ) );
// Boosted because you understand the philosophical implications of your actions, and YOU LIKE THEM.
add_morale( MORALE_CANNIBAL, 15, 200 );
} else if( cannibal ) {
add_msg_if_player( m_good, _( "You indulge your shameful hunger." ) );
add_morale( MORALE_CANNIBAL, 10, 50 );
} else if( psycho && spiritual ) {
add_msg_if_player( _( "You greedily devour the taboo meat." ) );
// Small bonus for violating a taboo.
add_morale( MORALE_CANNIBAL, 5, 50 );
} else if( psycho ) {
add_msg_if_player( _( "Meh. You've eaten worse." ) );
} else if( spiritual ) {
add_msg_if_player( m_bad,
_( "This is probably going to count against you if there's still an afterlife." ) );
add_morale( MORALE_CANNIBAL, -60, -400, 600, 300 );
} else {
add_msg_if_player( m_bad, _( "You feel horrible for eating a person." ) );
add_morale( MORALE_CANNIBAL, -60, -400, 600, 300 );
}
}
// Allergy check
const auto allergy = allergy_type( food );
if( allergy != MORALE_NULL ) {
add_msg_if_player( m_bad, _( "Yuck! How can anybody eat this stuff?" ) );
add_morale( allergy, -75, -400, 300, 240 );
}
// Carnivores CAN eat junk food, but they won't like it much.
// Pizza-scraping happens in consume_effects.
if( has_trait( trait_id( "CARNIVORE" ) ) && food.has_flag( "ALLERGEN_JUNK" ) &&
!food.has_flag( "CARNIVORE_OK" ) ) {
add_msg_if_player( m_bad, _( "Your stomach begins gurgling and you feel bloated and ill." ) );
add_morale( MORALE_NO_DIGEST, -25, -125, 300, 240 );
}
if( !spoiled && chew && has_trait( trait_id( "SAPROPHAGE" ) ) ) {
// It's OK to *drink* things that haven't rotted. Alternative is to ban water. D:
add_msg_if_player( m_bad, _( "Your stomach begins gurgling and you feel bloated and ill." ) );
add_morale( MORALE_NO_DIGEST, -75, -400, 300, 240 );
}
if( food.has_flag( "URSINE_HONEY" ) && ( !crossed_threshold() ||
has_trait( trait_id( "THRESH_URSINE" ) ) ) &&
mutation_category_level["MUTCAT_URSINE"] > 40 ) {
//Need at least 5 bear mutations for effect to show, to filter out mutations in common with other mutcats
int honey_fun = has_trait( trait_id( "THRESH_URSINE" ) ) ?
std::min( mutation_category_level["MUTCAT_URSINE"] / 8, 20 ) :
mutation_category_level["MUTCAT_URSINE"] / 12;
if( honey_fun < 10 ) {
add_msg_if_player( m_good, _( "You find the sweet taste of honey surprisingly palatable." ) );
} else {
add_msg_if_player( m_good, _( "You feast upon the sweet honey." ) );
}
add_morale( MORALE_HONEY, honey_fun, 100 );
}
if( will_vomit ) {
vomit();
}
// chance to become parasitised
if( !( has_bionic( bio_digestion ) || has_trait( trait_id( "PARAIMMUNE" ) ) ) ) {
if( food.type->comestible->parasites > 0 && one_in( food.type->comestible->parasites ) ) {
switch( rng( 0, 3 ) ) {
case 0:
if( !has_trait( trait_id( "EATHEALTH" ) ) ) {
add_effect( effect_tapeworm, 1, num_bp, true );
}
break;
case 1:
if( !has_trait( trait_id( "ACIDBLOOD" ) ) ) {
add_effect( effect_bloodworms, 1, num_bp, true );
}
break;
case 2:
add_effect( effect_brainworms, 1, num_bp, true );
break;
case 3:
add_effect( effect_paincysts, 1, num_bp, true );
}
}
}
for( const auto &v : this->vitamins_from( food ) ) {
auto qty = has_effect( effect_tapeworm ) ? v.second / 2 : v.second;
// can never develop hypervitaminosis from consuming food
vitamin_mod( v.first, qty );
}
food.mod_charges( -1 );
return true;
}
void player::consume_effects( item &food, bool rotten )
{
if( !food.is_food() ) {
debugmsg( "called player::consume_effects with non-comestible" );
return;
}
const auto comest = food.type->comestible.get();
const int capacity = stomach_capacity();
if( has_trait( "THRESH_PLANT" ) && food.type->can_use( "PLANTBLECH" ) ) {
// Just keep nutrition capped, to prevent vomiting
cap_nutrition_thirst( *this, capacity, true, true );
return;
}
if( ( has_trait( "HERBIVORE" ) || has_trait( "RUMINANT" ) ) &&
food.has_any_flag( herbivore_blacklist ) ) {
// No good can come of this.
return;
}
float factor = 1.0f;
float hunger_factor = 1.0f;
bool unhealthy_allowed = true;
if( has_trait( "GIZZARD" ) ) {
factor *= 0.6f;
}
if( has_trait( "CARNIVORE" ) && food.has_flag( "CARNIVORE_OK" ) ) {
// At least partially edible
if( food.has_any_flag( carnivore_blacklist ) ) {
// Other things are in it, we only get partial benefits
add_msg_if_player( _( "You pick out the edible parts and throw away the rest." ) );
factor *= 0.5f;
} else {
// Carnivores don't get unhealthy off pure meat diets
unhealthy_allowed = false;
}
}
// Saprophages get full nutrition from rotting food
if( rotten && !has_trait( "SAPROPHAGE" ) ) {
// everyone else only gets a portion of the nutrition
hunger_factor *= rng_float( 0, 1 );
// and takes a health penalty if they aren't adapted
if( !has_trait( "SAPROVORE" ) && !has_bionic( "bio_digestion" ) ) {
mod_healthy_mod( -30, -200 );
}
}
// Bio-digestion gives extra nutrition
if( has_bionic( "bio_digestion" ) ) {
hunger_factor += rng_float( 0, 1 );
}
const auto nutr = nutrition_for( food.type );
mod_hunger( -nutr * factor * hunger_factor );
mod_thirst( -comest->quench * factor );
mod_stomach_food( nutr * factor * hunger_factor );
mod_stomach_water( comest->quench * factor );
if( unhealthy_allowed || comest->healthy > 0 ) {
// Effectively no cap on health modifiers from food
mod_healthy_mod( comest->healthy, ( comest->healthy >= 0 ) ? 200 : -200 );
}
if( comest->stim != 0 &&
( abs( stim ) < ( abs( comest->stim ) * 3 ) ||
sgn( stim ) != sgn( comest->stim ) ) ) {
if( comest->stim < 0 ) {
stim = std::max( comest->stim * 3, stim + comest->stim );
} else {
stim = std::min( comest->stim * 3, stim + comest->stim );
}
}
add_addiction( comest->add, comest->addict );
if( addiction_craving( comest->add ) != MORALE_NULL ) {
rem_morale( addiction_craving( comest->add ) );
}
if( food.has_flag( "HOT" ) && food.has_flag( "EATEN_HOT" ) ) {
add_morale( MORALE_FOOD_HOT, 5, 10 );
}
auto fun = comest->fun;
if( food.has_flag( "COLD" ) && food.has_flag( "EATEN_COLD" ) && fun > 0 ) {
if( fun > 0 ) {
add_morale( MORALE_FOOD_GOOD, fun * 3, fun * 3, 60, 30, false, food.type );
} else {
fun = 1;
}
}
const bool gourmand = has_trait( "GOURMAND" );
const bool hibernate = has_active_mutation( "HIBERNATE" );
if( gourmand ) {
if( fun < -2 ) {
add_morale( MORALE_FOOD_BAD, fun * 0.5, fun, 60, 30, false, food.type );
} else if( fun > 0 ) {
add_morale( MORALE_FOOD_GOOD, fun * 3, fun * 6, 60, 30, false, food.type );
}
} else if( fun < 0 ) {
add_morale( MORALE_FOOD_BAD, fun, fun * 6, 60, 30, false, food.type );
} else if( fun > 0 ) {
add_morale( MORALE_FOOD_GOOD, fun, fun * 4, 60, 30, false, food.type );
}
if( hibernate ) {
if( ( nutr > 0 && get_hunger() < -60 ) || ( comest->quench > 0 && get_thirst() < -60 ) ) {
//Tell the player what's going on
add_msg_if_player( _( "You gorge yourself, preparing to hibernate." ) );
if( one_in( 2 ) ) {
//50% chance of the food tiring you
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -200 ) || ( comest->quench > 0 && get_thirst() < -200 ) ) {
//Hibernation should cut burn to 60/day
add_msg_if_player( _( "You feel stocked for a day or two. Got your bed all ready and secured?" ) );
if( one_in( 2 ) ) {
//And another 50%, intended cumulative
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -400 ) || ( comest->quench > 0 && get_thirst() < -400 ) ) {
add_msg_if_player(
_( "Mmm. You can still fit some more in...but maybe you should get comfortable and sleep." ) );
if( !one_in( 3 ) ) {
//Third check, this one at 66%
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -600 ) || ( comest->quench > 0 && get_thirst() < -600 ) ) {
add_msg_if_player( _( "That filled a hole! Time for bed..." ) );
// At this point, you're done. Schlaf gut.
mod_fatigue( nutr );
}
}
// Moved here and changed a bit - it was too complex
// Incredibly minor stuff like this shouldn't require complexity
if( !is_npc() && has_trait( "SLIMESPAWNER" ) &&
( get_hunger() < capacity + 40 || get_thirst() < capacity + 40 ) ) {
add_msg_if_player( m_mixed,
_( "You feel as though you're going to split open! In a good way?" ) );
mod_pain( 5 );
std::vector<tripoint> valid;
for( const tripoint &dest : g->m.points_in_radius( pos(), 1 ) ) {
if( g->is_empty( dest ) ) {
valid.push_back( dest );
}
}
int numslime = 1;
for( int i = 0; i < numslime && !valid.empty(); i++ ) {
const tripoint target = random_entry_removed( valid );
if( g->summon_mon( mon_player_blob, target ) ) {
monster *slime = g->monster_at( target );
slime->friendly = -1;
}
}
mod_hunger( 40 );
mod_thirst( 40 );
//~slimespawns have *small voices* which may be the Nice equivalent
//~of the Rat King's ALL CAPS invective. Probably shared-brain telepathy.
add_msg_if_player( m_good, _( "hey, you look like me! let's work together!" ) );
}
// Last thing that happens before capping hunger
if( get_hunger() < capacity && has_trait( "EATHEALTH" ) ) {
int excess_food = capacity - get_hunger();
add_msg_player_or_npc( _( "You feel the %s filling you out." ),
_( "<npcname> looks better after eating the %s." ),
food.tname().c_str() );
// Guaranteed 1 HP healing, no matter what. You're welcome. ;-)
if( excess_food <= 5 ) {
healall( 1 );
} else {
// Straight conversion, except it's divided amongst all your body parts.
healall( excess_food /= 5 );
}
// Note: We want this here to prevent "you can't finish this" messages
set_hunger( capacity );
}
cap_nutrition_thirst( *this, capacity, nutr > 0, comest->quench > 0 );
}
void player::consume_effects( const item &food )
{
if( !food.is_comestible() ) {
debugmsg( "called player::consume_effects with non-comestible" );
return;
}
const auto &comest = *food.type->comestible;
const int capacity = stomach_capacity();
if( has_trait( trait_id( "THRESH_PLANT" ) ) && food.type->can_use( "PLANTBLECH" ) ) {
// Just keep nutrition capped, to prevent vomiting
cap_nutrition_thirst( *this, capacity, true, true );
return;
}
if( ( has_trait( trait_id( "HERBIVORE" ) ) || has_trait( trait_id( "RUMINANT" ) ) ) &&
food.has_any_flag( herbivore_blacklist ) ) {
// No good can come of this.
return;
}
// Rotten food causes health loss
const float relative_rot = food.get_relative_rot();
if( relative_rot > 1.0f && !has_trait( trait_id( "SAPROPHAGE" ) ) &&
!has_trait( trait_id( "SAPROVORE" ) ) && !has_bionic( bio_digestion ) ) {
const float rottedness = clamp( 2 * relative_rot - 2.0f, 0.1f, 1.0f );
// ~-1 health per 1 nutrition at halfway-rotten-away, ~0 at "just got rotten"
// But always round down
int h_loss = -rottedness * comest.nutr;
mod_healthy_mod( h_loss, -200 );
add_msg( m_debug, "%d health from %0.2f%% rotten food", h_loss, rottedness );
}
const auto nutr = nutrition_for( food );
mod_hunger( -nutr );
mod_thirst( -comest.quench );
mod_stomach_food( nutr );
mod_stomach_water( comest.quench );
if( comest.healthy != 0 ) {
// Effectively no cap on health modifiers from food
mod_healthy_mod( comest.healthy, ( comest.healthy >= 0 ) ? 200 : -200 );
}
if( comest.stim != 0 &&
( abs( stim ) < ( abs( comest.stim ) * 3 ) ||
sgn( stim ) != sgn( comest.stim ) ) ) {
if( comest.stim < 0 ) {
stim = std::max( comest.stim * 3, stim + comest.stim );
} else {
stim = std::min( comest.stim * 3, stim + comest.stim );
}
}
add_addiction( comest.add, comest.addict );
if( addiction_craving( comest.add ) != MORALE_NULL ) {
rem_morale( addiction_craving( comest.add ) );
}
// Morale is in minutes
int morale_time = HOURS( 2 ) / MINUTES( 1 );
if( food.has_flag( "HOT" ) && food.has_flag( "EATEN_HOT" ) ) {
morale_time = HOURS( 3 ) / MINUTES( 1 );
int clamped_nutr = std::max( 5, std::min( 20, nutr / 10 ) );
add_morale( MORALE_FOOD_HOT, clamped_nutr, 20, morale_time, morale_time / 2 );
}
std::pair<int, int> fun = fun_for( food );
if( fun.first < 0 ) {
add_morale( MORALE_FOOD_BAD, fun.first, fun.second, morale_time, morale_time / 2, false,
food.type );
} else if( fun.first > 0 ) {
add_morale( MORALE_FOOD_GOOD, fun.first, fun.second, morale_time, morale_time / 2, false,
food.type );
}
const bool hibernate = has_active_mutation( trait_id( "HIBERNATE" ) );
if( hibernate ) {
if( ( nutr > 0 && get_hunger() < -60 ) || ( comest.quench > 0 && get_thirst() < -60 ) ) {
//Tell the player what's going on
add_msg_if_player( _( "You gorge yourself, preparing to hibernate." ) );
if( one_in( 2 ) ) {
//50% chance of the food tiring you
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -200 ) || ( comest.quench > 0 && get_thirst() < -200 ) ) {
//Hibernation should cut burn to 60/day
add_msg_if_player( _( "You feel stocked for a day or two. Got your bed all ready and secured?" ) );
if( one_in( 2 ) ) {
//And another 50%, intended cumulative
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -400 ) || ( comest.quench > 0 && get_thirst() < -400 ) ) {
add_msg_if_player(
_( "Mmm. You can still fit some more in...but maybe you should get comfortable and sleep." ) );
if( !one_in( 3 ) ) {
//Third check, this one at 66%
mod_fatigue( nutr );
}
}
if( ( nutr > 0 && get_hunger() < -600 ) || ( comest.quench > 0 && get_thirst() < -600 ) ) {
add_msg_if_player( _( "That filled a hole! Time for bed..." ) );
// At this point, you're done. Schlaf gut.
mod_fatigue( nutr );
}
}
// Moved here and changed a bit - it was too complex
// Incredibly minor stuff like this shouldn't require complexity
if( !is_npc() && has_trait( trait_id( "SLIMESPAWNER" ) ) &&
( get_hunger() < capacity + 40 || get_thirst() < capacity + 40 ) ) {
add_msg_if_player( m_mixed,
_( "You feel as though you're going to split open! In a good way?" ) );
mod_pain( 5 );
std::vector<tripoint> valid;
for( const tripoint &dest : g->m.points_in_radius( pos(), 1 ) ) {
if( g->is_empty( dest ) ) {
valid.push_back( dest );
}
}
int numslime = 1;
for( int i = 0; i < numslime && !valid.empty(); i++ ) {
const tripoint target = random_entry_removed( valid );
if( monster *const slime = g->summon_mon( mon_player_blob, target ) ) {
slime->friendly = -1;
}
}
mod_hunger( 40 );
mod_thirst( 40 );
//~slimespawns have *small voices* which may be the Nice equivalent
//~of the Rat King's ALL CAPS invective. Probably shared-brain telepathy.
add_msg_if_player( m_good, _( "hey, you look like me! let's work together!" ) );
}
// Last thing that happens before capping hunger
if( get_hunger() < capacity && has_trait( trait_id( "EATHEALTH" ) ) ) {
int excess_food = capacity - get_hunger();
add_msg_player_or_npc( _( "You feel the %s filling you out." ),
_( "<npcname> looks better after eating the %s." ),
food.tname().c_str() );
// Guaranteed 1 HP healing, no matter what. You're welcome. ;-)
if( excess_food <= 5 ) {
healall( 1 );
} else {
// Straight conversion, except it's divided amongst all your body parts.
healall( excess_food /= 5 );
}
// Note: We want this here to prevent "you can't finish this" messages
set_hunger( capacity );
}
cap_nutrition_thirst( *this, capacity, nutr > 0, comest.quench > 0 );
}