std::list<item> player::consume_items( const comp_selection<item_comp> &is, int batch )
{
std::list<item> ret;
if( has_trait( trait_DEBUG_HS ) ) {
return ret;
}
item_comp selected_comp = is.comp;
const tripoint &loc = pos();
const bool by_charges = ( item::count_by_charges( selected_comp.type ) && selected_comp.count > 0 );
// Count given to use_amount/use_charges, changed by those functions!
long real_count = ( selected_comp.count > 0 ) ? selected_comp.count * batch : abs(
selected_comp.count );
// First try to get everything from the map, than (remaining amount) from player
if( is.use_from & use_from_map ) {
if( by_charges ) {
std::list<item> tmp = g->m.use_charges( loc, PICKUP_RANGE, selected_comp.type, real_count );
ret.splice( ret.end(), tmp );
} else {
std::list<item> tmp = g->m.use_amount( loc, PICKUP_RANGE, selected_comp.type,
real_count );
remove_ammo( tmp, *this );
ret.splice( ret.end(), tmp );
}
}
if( is.use_from & use_from_player ) {
if( by_charges ) {
std::list<item> tmp = use_charges( selected_comp.type, real_count );
ret.splice( ret.end(), tmp );
} else {
std::list<item> tmp = use_amount( selected_comp.type, real_count );
remove_ammo( tmp, *this );
ret.splice( ret.end(), tmp );
}
}
// condense those items into one
if( by_charges && ret.size() > 1 ) {
std::list<item>::iterator b = ret.begin();
b++;
while( ret.size() > 1 ) {
ret.front().charges += b->charges;
b = ret.erase( b );
}
}
lastconsumed = selected_comp.type;
empty_buckets( *this );
return ret;
}
/* we use this if we selected the tool earlier */
void player::consume_tools( const comp_selection<tool_comp> &tool, int batch )
{
if( has_trait( trait_DEBUG_HS ) ) {
return;
}
if( tool.use_from & use_from_player ) {
use_charges( tool.comp.type, tool.comp.count * batch );
}
if( tool.use_from & use_from_map ) {
long quantity = tool.comp.count * batch;
g->m.use_charges( pos(), PICKUP_RANGE, tool.comp.type, quantity );
}
// else, use_from_none (or cancel), so we don't use up any tools;
}
void player::fire_gun(int tarx, int tary, bool burst) {
item ammotmp;
item* gunmod = weapon.active_gunmod();
it_ammo *curammo = NULL;
item *used_weapon = NULL;
if (weapon.has_flag("CHARGE")) { // It's a charger gun, so make up a type
// Charges maxes out at 8.
int charges = weapon.num_charges();
it_ammo *tmpammo = dynamic_cast<it_ammo*>(itypes["charge_shot"]);
tmpammo->damage = charges * charges;
tmpammo->pierce = (charges >= 4 ? (charges - 3) * 2.5 : 0);
if (charges <= 4)
tmpammo->dispersion = 14 - charges * 2;
else // 5, 12, 21, 32
tmpammo->dispersion = charges * (charges - 4);
tmpammo->recoil = tmpammo->dispersion * .8;
tmpammo->ammo_effects.clear(); // Reset effects.
if (charges == 8) { tmpammo->ammo_effects.insert("EXPLOSIVE_BIG"); }
else if (charges >= 6) { tmpammo->ammo_effects.insert("EXPLOSIVE"); }
if (charges >= 5){ tmpammo->ammo_effects.insert("FLAME"); }
else if (charges >= 4) { tmpammo->ammo_effects.insert("INCENDIARY"); }
if (gunmod != NULL) { // TODO: range calculation in case of active gunmod.
used_weapon = gunmod;
} else {
used_weapon = &weapon;
}
curammo = tmpammo;
used_weapon->curammo = tmpammo;
} else if (gunmod != NULL) {
used_weapon = gunmod;
curammo = used_weapon->curammo;
} else {// Just a normal gun. If we're here, we know curammo is valid.
curammo = weapon.curammo;
used_weapon = &weapon;
}
ammotmp = item(curammo, 0);
ammotmp.charges = 1;
if (!used_weapon->is_gun() && !used_weapon->is_gunmod()) {
debugmsg("%s tried to fire a non-gun (%s).", name.c_str(),
used_weapon->tname().c_str());
return;
}
projectile proj; // damage will be set later
proj.aoe_size = 0;
proj.ammo = curammo;
proj.speed = 1000;
std::set<std::string> *curammo_effects = &curammo->ammo_effects;
if(gunmod == NULL){
std::set<std::string> *gun_effects = &dynamic_cast<it_gun*>(used_weapon->type)->ammo_effects;
proj.proj_effects.insert(gun_effects->begin(),gun_effects->end());
}
proj.proj_effects.insert(curammo_effects->begin(),curammo_effects->end());
proj.wide = (curammo->phase == LIQUID ||
proj.proj_effects.count("SHOT") || proj.proj_effects.count("BOUNCE"));
proj.drops = (curammo->type == "bolt" || curammo->type == "arrow");
//int x = xpos(), y = ypos();
// Have to use the gun, gunmods don't have a type
it_gun* firing = dynamic_cast<it_gun*>(weapon.type);
if (has_trait("TRIGGERHAPPY") && one_in(30))
burst = true;
if (burst && used_weapon->burst_size() < 2)
burst = false; // Can't burst fire a semi-auto
// Use different amounts of time depending on the type of gun and our skill
if (!proj.proj_effects.count("BOUNCE")) {
moves -= time_to_fire(*this, firing);
}
// Decide how many shots to fire
int num_shots = 1;
if (burst)
num_shots = used_weapon->burst_size();
if (num_shots > used_weapon->num_charges() && !used_weapon->has_flag("CHARGE") && !used_weapon->has_flag("NO_AMMO"))
num_shots = used_weapon->num_charges();
if (num_shots == 0)
debugmsg("game::fire() - num_shots = 0!");
int ups_drain = 0;
int adv_ups_drain = 0;
if (weapon.has_flag("USE_UPS")) {
ups_drain = 5;
adv_ups_drain = 3;
} else if (weapon.has_flag("USE_UPS_20")) {
ups_drain = 20;
adv_ups_drain = 12;
} else if (weapon.has_flag("USE_UPS_40")) {
ups_drain = 40;
adv_ups_drain = 24;
}
// cap our maximum burst size by the amount of UPS power left
if (ups_drain > 0 || adv_ups_drain > 0)
while (!(has_charges("UPS_off", ups_drain*num_shots) ||
has_charges("UPS_on", ups_drain*num_shots) ||
has_charges("adv_UPS_off", adv_ups_drain*num_shots) ||
has_charges("adv_UPS_on", adv_ups_drain*num_shots))) {
num_shots--;
}
const bool debug_retarget = false; // this will inevitably be needed
//const bool wildly_spraying = false; // stub for now. later, rng based on stress/skill/etc at the start,
int weaponrange = weapon.range(); // this is expensive, let's cache. todo: figure out if we need weapon.range(&p);
for (int curshot = 0; curshot < num_shots; curshot++) {
// Burst-fire weapons allow us to pick a new target after killing the first
int zid = g->mon_at(tarx, tary);
if ( curshot > 0 && (zid == -1 || g->zombie(zid).hp <= 0) ) {
std::vector<point> new_targets;
new_targets.clear();
if ( debug_retarget == true ) {
mvprintz(curshot,5,c_red,"[%d] %s: retarget: mon_at(%d,%d)",curshot,name.c_str(),tarx,tary);
if(zid == -1) {
printz(c_red, " = -1");
} else {
printz(c_red, ".hp=%d", g->zombie(zid).hp);
}
}
for (unsigned long int i = 0; i < g->num_zombies(); i++) {
monster &z = g->zombie(i);
int dummy;
// search for monsters in radius
if (rl_dist(z.posx(), z.posy(), tarx, tary) <= std::min(2 + skillLevel("gun"), weaponrange) &&
rl_dist(xpos(),ypos(),z.xpos(),z.ypos()) <= weaponrange &&
sees(&z, dummy) ) {
if (!z.is_dead_state())
new_targets.push_back(point(z.xpos(), z.ypos())); // oh you're not dead and I don't like you. Hello!
}
}
if ( new_targets.empty() == false ) { /* new victim! or last victim moved */
int target_picked = rng(0, new_targets.size() - 1); /* 1 victim list unless wildly spraying */
tarx = new_targets[target_picked].x;
tary = new_targets[target_picked].y;
zid = g->mon_at(tarx, tary);
/* debug */ if (debug_retarget) printz(c_ltgreen, " NEW:(%d:%d,%d) %d,%d (%s)[%d] hp: %d",
target_picked, new_targets[target_picked].x, new_targets[target_picked].y,
tarx, tary, g->zombie(zid).name().c_str(), zid, g->zombie(zid).hp);
} else if (
(
!has_trait("TRIGGERHAPPY") || /* double ta TRIPLE TAP! wait, no... */
one_in(3) /* on second though...everyone double-taps at times. */
) && (
skillLevel("gun") >= 7 || /* unless trained */
one_in(7 - skillLevel("gun")) /* ...sometimes */
) ) {
return; // No targets, so return
} else if (debug_retarget) {
printz(c_red, " new targets.empty()!");
}
} else if (debug_retarget) {
const int zid = g->mon_at(tarx, tary);
mvprintz(curshot,5,c_red,"[%d] %s: target == mon_at(%d,%d)[%d] %s hp %d",curshot, name.c_str(), tarx ,tary,
zid,
g->zombie(zid).name().c_str(),
g->zombie(zid).hp);
}
// Drop a shell casing if appropriate.
itype_id casing_type = curammo->casing;
if (casing_type != "NULL" && !casing_type.empty()) {
item casing;
casing.make(itypes[casing_type]);
// Casing needs a charges of 1 to stack properly with other casings.
casing.charges = 1;
if( used_weapon->has_gunmod("brass_catcher") != -1 ) {
i_add( casing );
} else {
int x = 0;
int y = 0;
int count = 0;
do {
x = xpos() - 1 + rng(0, 2);
y = ypos() - 1 + rng(0, 2);
count++;
// Try not to drop the casing on a wall if at all possible.
} while( g->m.move_cost( x, y ) == 0 && count < 10 );
g->m.add_item_or_charges(x, y, casing);
}
}
// Use up a round (or 100)
if (used_weapon->has_flag("FIRE_100")) {
used_weapon->charges -= 100;
} else if (used_weapon->has_flag("FIRE_50")) {
used_weapon->charges -= 50;
} else if (used_weapon->has_flag("CHARGE")) {
used_weapon->active = false;
used_weapon->charges = 0;
} else if (!used_weapon->has_flag("NO_AMMO")) {
used_weapon->charges--;
}
// Drain UPS power
if (has_charges("adv_UPS_off", adv_ups_drain)) {
use_charges("adv_UPS_off", adv_ups_drain);
} else if (has_charges("adv_UPS_on", adv_ups_drain)) {
use_charges("adv_UPS_on", adv_ups_drain);
} else if (has_charges("UPS_off", ups_drain)) {
use_charges("UPS_off", ups_drain);
} else if (has_charges("UPS_on", ups_drain)) {
use_charges("UPS_on", ups_drain);
}
if (firing->skill_used != Skill::skill("archery") &&
firing->skill_used != Skill::skill("throw")) {
// Current guns have a durability between 5 and 9.
// Misfire chance is between 1/64 and 1/1024.
if (is_underwater() && !weapon.has_flag("WATERPROOF_GUN") && one_in(firing->durability)) {
g->add_msg_player_or_npc(this, _("Your weapon misfires with a wet click!"),
_("<npcname>'s weapon misfires with a wet click!") );
return;
} else if (one_in(2 << firing->durability)) {
g->add_msg_player_or_npc(this, _("Your weapon misfires!"),
_("<npcname>'s weapon misfires!") );
return;
}
}
make_gun_sound_effect(*this, burst, used_weapon);
double total_dispersion = get_weapon_dispersion(used_weapon);
//debugmsg("%f",total_dispersion);
int range = rl_dist(xpos(), ypos(), tarx, tary);
// penalties for point-blank
if (range < (firing->volume/3) && firing->ammo != "shot")
total_dispersion *= double(firing->volume/3) / double(range);
// rifle has less range penalty past LONG_RANGE
if (firing->skill_used == Skill::skill("rifle") && range > LONG_RANGE)
total_dispersion *= 1 - 0.4*double(range - LONG_RANGE) / double(range);
if (curshot > 0) {
if (recoil_add(*this) % 2 == 1) {
recoil++;
}
recoil += recoil_add(*this) / 2;
} else {
recoil += recoil_add(*this);
}
int mtarx = tarx;
int mtary = tary;
int adjusted_damage = used_weapon->gun_damage();
proj.impact = damage_instance::physical(0,adjusted_damage,0);
double missed_by = projectile_attack(proj, mtarx, mtary, total_dispersion);
if (missed_by <= .1) { // TODO: check head existence for headshot
practice(g->turn, firing->skill_used, 5);
lifetime_stats()->headshots++;
} else if (missed_by <= .2) {
practice(g->turn, firing->skill_used, 3);
} else if (missed_by <= .4) {
practice(g->turn, firing->skill_used, 2);
} else if (missed_by <= .6) {
practice(g->turn, firing->skill_used, 1);
}
}
if (used_weapon->num_charges() == 0) {
used_weapon->curammo = NULL;
}
}
bool player::uninstall_bionic(bionic_id b_id)
{
// malfunctioning bionics don't have associated items and get a difficulty of 12
int difficulty = 12;
if( item_controller->has_template(b_id) > 0) {
const it_bionic *type = dynamic_cast<it_bionic *> (item_controller->find_template(b_id));
difficulty = type->difficulty;
}
if (!has_bionic(b_id)) {
popup(_("You don't have this bionic installed."));
return false;
}
if (!(inv.has_items_with_quality("CUT", 1, 1) && has_amount("1st_aid", 1))) {
popup(_("Removing bionics requires a cutting tool and a first aid kit."));
return false;
}
if ( b_id == "bio_blaster" ) {
popup(_("Removing your Fusion Blaster Arm would leave you with a useless stump."));
return false;
}
// removal of bionics adds +2 difficulty over installation
int chance_of_success = bionic_manip_cos(int_cur,
skillLevel("electronics"),
skillLevel("firstaid"),
skillLevel("mechanics"),
difficulty + 2);
if (!query_yn(_("WARNING: %i percent chance of SEVERE bodily damage! Remove anyway?"),
100 - chance_of_success)) {
return false;
}
use_charges("1st_aid", 1);
practice( "electronics", int((100 - chance_of_success) * 1.5) );
practice( "firstaid", int((100 - chance_of_success) * 1.0) );
practice( "mechanics", int((100 - chance_of_success) * 0.5) );
int success = chance_of_success - rng(1, 100);
if (success > 0) {
add_memorial_log(pgettext("memorial_male", "Removed bionic: %s."),
pgettext("memorial_female", "Removed bionic: %s."),
bionics[b_id]->name.c_str());
// until bionics can be flagged as non-removable
add_msg(m_neutral, _("You jiggle your parts back into their familiar places."));
add_msg(m_good, _("Successfully removed %s."), bionics[b_id]->name.c_str());
remove_bionic(b_id);
g->m.spawn_item(posx, posy, "burnt_out_bionic", 1);
} else {
add_memorial_log(pgettext("memorial_male", "Removed bionic: %s."),
pgettext("memorial_female", "Removed bionic: %s."),
bionics[b_id]->name.c_str());
bionics_uninstall_failure(this);
}
g->refresh_all();
return true;
}
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;
}