void BrickWallDemo::createBrickWall( hkpWorld* world, int height, int length, const hkVector4& position, hkReal gapWidth, hkpConvexShape* box, hkVector4Parameter halfExtents )
{
hkVector4 posx = position;
// do a raycast to place the ragdoll
{
hkpWorldRayCastInput ray;
ray.m_from = posx;
ray.m_to = posx;
ray.m_from(1) += 20.0f;
ray.m_to(1) -= 20.0f;
hkpWorldRayCastOutput result;
world->castRay( ray, result );
posx.setInterpolate4( ray.m_from, ray.m_to, result.m_hitFraction );
}
// move the start point
posx(0) -= ( gapWidth + 2.0f * halfExtents(0) ) * length * 0.5f;
posx(1) -= halfExtents(1) + box->getRadius();
hkArray<hkpEntity*> entitiesToAdd;
for ( int x = 0; x < length; x ++ ) // along the ground
{
hkVector4 pos = posx;
for( int ii = 0; ii < height; ii++ )
{
pos(1) += (halfExtents(1) + box->getRadius())* 2.0f;
hkpRigidBodyCinfo boxInfo;
boxInfo.m_mass = 10.0f;
hkpMassProperties massProperties;
hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfExtents, boxInfo.m_mass, massProperties);
boxInfo.m_mass = massProperties.m_mass;
boxInfo.m_centerOfMass = massProperties.m_centerOfMass;
boxInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
boxInfo.m_solverDeactivation = boxInfo.SOLVER_DEACTIVATION_MEDIUM;
boxInfo.m_shape = box;
//boxInfo.m_qualityType = HK_COLLIDABLE_QUALITY_DEBRIS;
boxInfo.m_restitution = 0.0f;
boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
{
boxInfo.m_position = pos;
hkpRigidBody* boxRigidBody = new hkpRigidBody(boxInfo);
world->addEntity( boxRigidBody );
boxRigidBody->removeReference();
}
pos(1) += (halfExtents(1) + box->getRadius())* 2.0f;
pos(0) += halfExtents(0) * 0.6f;
{
boxInfo.m_position = pos;
hkpRigidBody* boxRigidBody = new hkpRigidBody(boxInfo);
entitiesToAdd.pushBack(boxRigidBody);
}
pos(0) -= halfExtents(0) * 0.6f;
}
posx(0) += halfExtents(0)* 2.0f + gapWidth;
}
world->addEntityBatch( entitiesToAdd.begin(), entitiesToAdd.getSize());
for (int i=0; i < entitiesToAdd.getSize(); i++){ entitiesToAdd[i]->removeReference(); }
}
void monster::die(Creature* nkiller) {
if( dead ) {
// We are already dead, don't die again, note that monster::dead is
// *only* set to true in this function!
return;
}
dead = true;
set_killer( nkiller );
if( hp < -( type->size < MS_MEDIUM ? 1.5 : 3 ) * type->hp ) {
explode(); // Explode them if it was big overkill
}
if (!no_extra_death_drops) {
drop_items_on_death();
}
// TODO: should actually be class Character
player *ch = dynamic_cast<player*>( get_killer() );
if( !is_hallucination() && ch != nullptr ) {
if( has_flag( MF_GUILT ) || ( ch->has_trait( "PACIFIST" ) && has_flag( MF_HUMAN ) ) ) {
// has guilt flag or player is pacifist && monster is humanoid
mdeath::guilt(this);
}
// TODO: add a kill counter to npcs?
if( ch->is_player() ) {
g->increase_kill_count( type->id );
}
if( type->difficulty >= 30 ) {
ch->add_memorial_log( pgettext( "memorial_male", "Killed a %s." ),
pgettext( "memorial_female", "Killed a %s." ),
name().c_str() );
}
}
// We were tied up at the moment of death, add a short rope to inventory
if ( has_effect("tied") ) {
item rope_6("rope_6", 0);
add_item(rope_6);
}
if( !is_hallucination() ) {
for( const auto &it : inv ) {
g->m.add_item_or_charges( posx(), posy(), it );
}
}
// If we're a queen, make nearby groups of our type start to die out
if( !is_hallucination() && has_flag( MF_QUEEN ) ) {
// The submap coordinates of this monster, monster groups coordinates are
// submap coordinates.
const point abssub = overmapbuffer::ms_to_sm_copy( g->m.getabs( posx(), posy() ) );
// Do it for overmap above/below too
for( int z = 1; z >= -1; --z ) {
for( int x = -MAPSIZE / 2; x <= MAPSIZE / 2; x++ ) {
for( int y = -MAPSIZE / 2; y <= MAPSIZE / 2; y++ ) {
std::vector<mongroup*> groups = overmap_buffer.groups_at( abssub.x + x, abssub.y + y, g->levz + z );
for( auto &mgp : groups ) {
if( MonsterGroupManager::IsMonsterInGroup( mgp->type, type->id ) ) {
mgp->dying = true;
}
}
}
}
}
}
// If we're a mission monster, update the mission
if (!is_hallucination() && mission_id != -1) {
mission_type *misstype = g->find_mission_type(mission_id);
if (misstype->goal == MGOAL_FIND_MONSTER) {
g->fail_mission(mission_id);
}
if (misstype->goal == MGOAL_KILL_MONSTER) {
g->mission_step_complete(mission_id, 1);
}
}
// Also, perform our death function
if(is_hallucination()) {
//Hallucinations always just disappear
mdeath::disappear(this);
return;
}
//Not a hallucination, go process the death effects.
for (auto const &deathfunction : type->dies) {
deathfunction(this);
}
// If our species fears seeing one of our own die, process that
int anger_adjust = 0, morale_adjust = 0;
if (type->has_anger_trigger(MTRIG_FRIEND_DIED)){
anger_adjust += 15;
}
if (type->has_fear_trigger(MTRIG_FRIEND_DIED)){
morale_adjust -= 15;
}
if (type->has_placate_trigger(MTRIG_FRIEND_DIED)){
anger_adjust -= 15;
}
if (anger_adjust != 0 || morale_adjust != 0) {
int light = g->light_level();
for (size_t i = 0; i < g->num_zombies(); i++) {
monster &critter = g->zombie( i );
if( !critter.type->same_species( *type ) ) {
continue;
}
int t = 0;
if( g->m.sees( critter.pos(), pos(), light, t ) ) {
critter.morale += morale_adjust;
critter.anger += anger_adjust;
}
}
}
}
bool monster::move_effects()
{
bool u_see_me = g->u.sees(*this);
if (has_effect("tied")) {
return false;
}
if (has_effect("downed")) {
remove_effect("downed");
if (u_see_me) {
add_msg(_("The %s climbs to it's feet!"), name().c_str());
}
return false;
}
if (has_effect("webbed")) {
if (x_in_y(type->melee_dice * type->melee_sides, 6 * get_effect_int("webbed"))) {
if (u_see_me) {
add_msg(_("The %s breaks free of the webs!"), name().c_str());
}
remove_effect("webbed");
}
return false;
}
if (has_effect("lightsnare")) {
if(x_in_y(type->melee_dice * type->melee_sides, 12)) {
remove_effect("lightsnare");
g->m.spawn_item(posx(), posy(), "string_36");
g->m.spawn_item(posx(), posy(), "snare_trigger");
if (u_see_me) {
add_msg(_("The %s escapes the light snare!"), name().c_str());
}
}
return false;
}
if (has_effect("heavysnare")) {
if (type->melee_dice * type->melee_sides >= 7) {
if(x_in_y(type->melee_dice * type->melee_sides, 32)) {
remove_effect("heavysnare");
g->m.spawn_item(posx(), posy(), "rope_6");
g->m.spawn_item(posx(), posy(), "snare_trigger");
if (u_see_me) {
add_msg(_("The %s escapes the heavy snare!"), name().c_str());
}
}
}
return false;
}
if (has_effect("beartrap")) {
if (type->melee_dice * type->melee_sides >= 18) {
if(x_in_y(type->melee_dice * type->melee_sides, 200)) {
remove_effect("beartrap");
g->m.spawn_item(posx(), posy(), "beartrap");
if (u_see_me) {
add_msg(_("The %s escapes the bear trap!"), name().c_str());
}
}
}
return false;
}
if (has_effect("crushed")) {
// Strength helps in getting free, but dex also helps you worm your way out of the rubble
if(x_in_y(type->melee_dice * type->melee_sides, 100)) {
remove_effect("crushed");
if (u_see_me) {
add_msg(_("The %s frees itself from the rubble!"), name().c_str());
}
}
return false;
}
// If we ever get more effects that force movement on success this will need to be reworked to
// only trigger success effects if /all/ rolls succeed
if (has_effect("in_pit")) {
if (rng(0, 40) > type->melee_dice * type->melee_sides) {
return false;
} else {
if (u_see_me) {
add_msg(_("The %s escapes the pit!"), name().c_str());
}
remove_effect("in_pit");
}
}
return Creature::move_effects();
}
tripoint monster::wander_next()
{
tripoint next = pos();
bool xbest = true;
if( abs( wander_pos.y - posy() ) > abs( wander_pos.x - posx() ) ) {
// Which is more important
xbest = false;
}
int x = posx(), x2 = posx() - 1, x3 = posx() + 1;
int y = posy(), y2 = posy() - 1, y3 = posy() + 1;
int z = posz();
// Used to avoid checking same points 3 times when moving in a straight line
// *_move is true if pos*() != wander_pos.*
bool x_move = true;
bool y_move = true;
bool z_move = true;
if( wander_pos.x < posx() ) {
x--;
x2++;
} else if( wander_pos.x > posx() ) {
x++;
x2++;
x3 -= 2;
} else {
x_move = false;
}
if( wander_pos.y < posy() ) {
y--;
y2++;
} else if( wander_pos.y > posy() ) {
y++;
y2++;
y3 -= 2;
} else {
y_move = false;
}
if( wander_pos.z < posz() ) {
z--;
} else if( wander_pos.z > posz() ) {
z++;
} else {
z_move = false;
}
if( !x_move && !y_move && !z_move ) {
return next;
}
// Any creature can "fly" downwards
const bool flies = z < posz() || has_flag( MF_FLIES );
const bool climbs = has_flag( MF_CLIMBS );
const bool canbash = has_flag( MF_BASHES ) || has_flag( MF_BORES );
const int bash_est = bash_estimate();
// Check if we can move into position, attack player on position or bash position
// If yes, set next to this position and return true, otherwise return false
const auto try_pos = [&]( const int x, const int y, const int z ) {
tripoint dest( x, y, z );
if( ( canbash && g->m.bash_rating( bash_est, dest ) > 0 ) ||
( ( flies || g->m.has_floor_or_support( dest ) ) &&
can_move_to( dest ) ) ) {
next = dest;
return true;
}
return false;
};
bool found = false;
const bool can_climb = z_move && (flies || climbs || g->m.has_flag( TFLAG_RAMP, pos() ));
if( z_move && g->m.valid_move( pos(), tripoint( posx(), posy(), z ), false, can_climb ) ) {
found = true;
if( ( x_move || y_move ) && try_pos( x, y, z ) ) {
} else if( y_move && try_pos( x, y2, z ) ) {
} else if( x_move && try_pos( x2, y, z ) ) {
} else if( y_move && try_pos( x, y3, z ) ) {
} else if( x_move && try_pos( x3, y, z ) ) {
} else if( try_pos( posx(), posy(), z ) ) {
} else {
found = false;
}
}
if( found ) {
return next;
}
if( xbest ) {
if( ( x_move || y_move ) && try_pos( x, y, posz() ) ) {
// Do nothing in each of those ifs, the if-else is just for convenience
} else if( y_move && try_pos( x, y2, posz() ) ) {
} else if( x_move && try_pos( x2, y, posz() ) ) {
} else if( y_move && try_pos( x, y3, posz() ) ) {
} else if( x_move && try_pos( x3, y, posz() ) ) {
}
} else {
if( ( x_move || y_move ) && try_pos( x, y, posz() ) ) {
} else if( x_move && try_pos( x2, y, posz() ) ) {
} else if( y_move && try_pos( x, y2, posz() ) ) {
} else if( x_move && try_pos( x3, y, posz() ) ) {
} else if( y_move && try_pos( x, y3, posz() ) ) {
}
}
return next;
}
bool Character::move_effects()
{
if (has_effect("downed")) {
if (rng(0, 40) > get_dex() + int(get_str() / 2)) {
add_msg_if_player(_("You struggle to stand."));
} else {
add_msg_player_or_npc(m_good, _("You stand up."),
_("<npcname> stands up."));
remove_effect("downed");
}
return false;
}
if (has_effect("webbed")) {
if (x_in_y(get_str(), 6 * get_effect_int("webbed"))) {
add_msg_player_or_npc(m_good, _("You free yourself from the webs!"),
_("<npcname> frees themselves from the webs!"));
remove_effect("webbed");
} else {
add_msg_if_player(_("You try to free yourself from the webs, but can't get loose!"));
}
return false;
}
if (has_effect("lightsnare")) {
if(x_in_y(get_str(), 12) || x_in_y(get_dex(), 8)) {
remove_effect("lightsnare");
add_msg_player_or_npc(m_good, _("You free yourself from the light snare!"),
_("<npcname> frees themselves from the light snare!"));
item string("string_36", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), string);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the light snare, but can't get loose!"));
}
return false;
}
if (has_effect("heavysnare")) {
if(x_in_y(get_str(), 32) || x_in_y(get_dex(), 16)) {
remove_effect("heavysnare");
add_msg_player_or_npc(m_good, _("You free yourself from the heavy snare!"),
_("<npcname> frees themselves from the heavy snare!"));
item rope("rope_6", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), rope);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the heavy snare, but can't get loose!"));
}
return false;
}
if (has_effect("beartrap")) {
/* Real bear traps can't be removed without the proper tools or immense strength; eventually this should
allow normal players two options: removal of the limb or removal of the trap from the ground
(at which point the player could later remove it from the leg with the right tools).
As such we are currently making it a bit easier for players and NPC's to get out of bear traps.
*/
if(x_in_y(get_str(), 100)) {
remove_effect("beartrap");
add_msg_player_or_npc(m_good, _("You free yourself from the bear trap!"),
_("<npcname> frees themselves from the bear trap!"));
item beartrap("beartrap", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), beartrap);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the bear trap, but can't get loose!"));
}
return false;
}
if (has_effect("crushed")) {
// Strength helps in getting free, but dex also helps you worm your way out of the rubble
if(x_in_y(get_str() + get_dex() / 4, 100)) {
remove_effect("crushed");
add_msg_player_or_npc(m_good, _("You free yourself from the rubble!"),
_("<npcname> frees themselves from the rubble!"));
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the rubble, but can't get loose!"));
}
return false;
}
if (has_effect("amigara")) {
int curdist = 999, newdist = 999;
for (int cx = 0; cx < SEEX * MAPSIZE; cx++) {
for (int cy = 0; cy < SEEY * MAPSIZE; cy++) {
if (g->m.ter(cx, cy) == t_fault) {
int dist = rl_dist(cx, cy, posx(), posy());
if (dist < curdist) {
curdist = dist;
}
dist = rl_dist(cx, cy, posx(), posy());
if (dist < newdist) {
newdist = dist;
}
}
}
}
if (newdist > curdist) {
add_msg_if_player(m_info, _("You cannot pull yourself away from the faultline..."));
return false;
}
}
// Below this point are things that allow for movement if they succeed
// Currently we only have one thing that forces movement if you succeed, should we get more
// than this will need to be reworked to only have success effects if /all/ checks succeed
if (has_effect("in_pit")) {
if (rng(0, 40) > get_str() + int(get_dex() / 2)) {
add_msg_if_player(m_bad, _("You try to escape the pit, but slip back in."));
return false;
} else {
add_msg_player_or_npc(m_good, _("You escape the pit!"),
_("<npcname> escapes the pit!"));
remove_effect("in_pit");
}
}
return Creature::move_effects();
}
void monster::knock_back_from( const tripoint &p )
{
if( p == pos() ) {
return; // No effect
}
if( is_hallucination() ) {
die( nullptr );
return;
}
tripoint to = pos();;
if( p.x < posx() ) {
to.x++;
}
if( p.x > posx() ) {
to.x--;
}
if( p.y < posy() ) {
to.y++;
}
if( p.y > posy() ) {
to.y--;
}
bool u_see = g->u.sees( to );
// First, see if we hit another monster
if( monster *const z = g->critter_at<monster>( to ) ) {
apply_damage( z, bp_torso, z->type->size );
add_effect( effect_stunned, 1_turns );
if( type->size > 1 + z->type->size ) {
z->knock_back_from( pos() ); // Chain reaction!
z->apply_damage( this, bp_torso, type->size );
z->add_effect( effect_stunned, 1_turns );
} else if( type->size > z->type->size ) {
z->apply_damage( this, bp_torso, type->size );
z->add_effect( effect_stunned, 1_turns );
}
z->check_dead_state();
if( u_see ) {
add_msg( _( "The %1$s bounces off a %2$s!" ), name().c_str(), z->name().c_str() );
}
return;
}
if( npc *const p = g->critter_at<npc>( to ) ) {
apply_damage( p, bp_torso, 3 );
add_effect( effect_stunned, 1_turns );
p->deal_damage( this, bp_torso, damage_instance( DT_BASH, type->size ) );
if( u_see ) {
add_msg( _( "The %1$s bounces off %2$s!" ), name().c_str(), p->name.c_str() );
}
p->check_dead_state();
return;
}
// If we're still in the function at this point, we're actually moving a tile!
if( g->m.has_flag_ter( TFLAG_DEEP_WATER, to ) ) {
if( g->m.has_flag( "LIQUID", to ) && can_drown() ) {
die( nullptr );
if( u_see ) {
add_msg( _( "The %s drowns!" ), name().c_str() );
}
} else if( has_flag( MF_AQUATIC ) ) { // We swim but we're NOT in water
die( nullptr );
if( u_see ) {
add_msg( _( "The %s flops around and dies!" ), name().c_str() );
}
}
}
if( g->m.impassable( to ) ) {
// It's some kind of wall.
apply_damage( nullptr, bp_torso, type->size );
add_effect( effect_stunned, 2_turns );
if( u_see ) {
add_msg( _( "The %1$s bounces off a %2$s." ), name().c_str(),
g->m.obstacle_name( to ).c_str() );
}
} else { // It's no wall
setpos( to );
}
check_dead_state();
}
void monster::knock_back_from( const tripoint &p )
{
if( p == pos3() ) {
return; // No effect
}
if( is_hallucination() ) {
die( nullptr );
return;
}
tripoint to = pos3();;
if( p.x < posx() ) {
to.x++;
}
if( p.x > posx() ) {
to.x--;
}
if( p.y < posy() ) {
to.y++;
}
if( p.y > posy() ) {
to.y--;
}
bool u_see = g->u.sees( to );
// First, see if we hit another monster
int mondex = g->mon_at( to );
if( mondex != -1 ) {
monster *z = &( g->zombie( mondex ) );
apply_damage( z, bp_torso, z->type->size );
add_effect( "stunned", 1 );
if( type->size > 1 + z->type->size ) {
z->knock_back_from( pos3() ); // Chain reaction!
z->apply_damage( this, bp_torso, type->size );
z->add_effect( "stunned", 1 );
} else if( type->size > z->type->size ) {
z->apply_damage( this, bp_torso, type->size );
z->add_effect( "stunned", 1 );
}
z->check_dead_state();
if( u_see ) {
add_msg( _( "The %1$s bounces off a %2$s!" ), name().c_str(), z->name().c_str() );
}
return;
}
int npcdex = g->npc_at( to );
if( npcdex != -1 ) {
npc *p = g->active_npc[npcdex];
apply_damage( p, bp_torso, 3 );
add_effect( "stunned", 1 );
p->deal_damage( this, bp_torso, damage_instance( DT_BASH, type->size ) );
if( u_see ) {
add_msg( _( "The %1$s bounces off %2$s!" ), name().c_str(), p->name.c_str() );
}
p->check_dead_state();
return;
}
// If we're still in the function at this point, we're actually moving a tile!
if( g->m.ter_at( to ).has_flag( TFLAG_DEEP_WATER ) ) {
if( g->m.has_flag( "LIQUID", to ) && can_drown() ) {
die( nullptr );
if( u_see ) {
add_msg( _( "The %s drowns!" ), name().c_str() );
}
} else if( has_flag( MF_AQUATIC ) ) { // We swim but we're NOT in water
die( nullptr );
if( u_see ) {
add_msg( _( "The %s flops around and dies!" ), name().c_str() );
}
}
}
if( g->m.move_cost( to ) == 0 ) {
// It's some kind of wall.
apply_damage( nullptr, bp_torso, type->size );
add_effect( "stunned", 2 );
if( u_see ) {
add_msg( _( "The %1$s bounces off a %2$s." ), name().c_str(),
g->m.tername( to ).c_str() );
}
} else { // It's no wall
setpos( to );
}
check_dead_state();
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move()
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0) {
wandf--;
}
//Hallucinations have a chance of disappearing each turn
if (is_hallucination() && one_in(25)) {
die();
return;
}
// First, use the special attack, if we can!
if (sp_timeout > 0) {
sp_timeout--;
}
//If this monster has the ability to heal in combat, do it now.
if (has_flag(MF_REGENERATES_50)) {
if (hp < type->hp) {
if (one_in(2)) {
add_msg(_("The %s is visibly regenerating!"), name().c_str());
}
hp += 50;
if(hp > type->hp) {
hp = type->hp;
}
}
}
if (has_flag(MF_REGENERATES_10)) {
if (hp < type->hp) {
if (one_in(2)) {
add_msg(_("The %s seems a little healthier."), name().c_str());
}
hp += 10;
if(hp > type->hp) {
hp = type->hp;
}
}
}
//The monster can consume objects it stands on. Check if there are any.
//If there are. Consume them.
if (has_flag(MF_ABSORBS)) {
if(!g->m.i_at(posx(), posy()).empty()) {
add_msg(_("The %s flows around the objects on the floor and they are quickly dissolved!"), name().c_str());
std::vector<item> items_absorbed = g->m.i_at(posx(), posy());
for( size_t i = 0; i < items_absorbed.size(); ++i ) {
hp += items_absorbed.at(i).volume(); //Yeah this means it can get more HP than normal.
}
g->m.i_clear(posx(), posy());
}
}
//Monster will regen morale and agression if it is on max HP
//It regens more morale and agression if is currently fleeing.
if(has_flag(MF_REGENMORALE) && hp >= type->hp){
if(is_fleeing(g->u)){
morale = type->morale;
anger = type->agro;
}
if(morale <= type->morale)
morale += 1;
if(anger <= type->agro)
anger += 1;
if(morale < 0)
morale += 5;
if(anger < 0)
anger += 5;
}
// If this critter dies in sunlight, check & assess damage.
if (g->is_in_sunlight(posx(), posy()) && has_flag(MF_SUNDEATH)) {
add_msg(_("The %s burns horribly in the sunlight!"), name().c_str());
hp -= 100;
if(hp < 0) {
hp = 0 ;
}
}
if (sp_timeout == 0 && (friendly == 0 || has_flag(MF_FRIENDLY_SPECIAL))) {
mattack ma;
if(!is_hallucination()) {
(ma.*type->sp_attack)(this);
}
}
if (moves < 0) {
return;
}
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect("stunned")) {
stumble(false);
moves = 0;
return;
}
if (has_effect("downed")) {
moves = 0;
return;
}
if (has_effect("bouldering")) {
moves -= 20;
if (moves < 0) {
return;
}
}
if (friendly != 0) {
if (friendly > 0) {
friendly--;
}
friendly_move();
return;
}
bool moved = false;
point next;
int mondex = (!plans.empty() ? g->mon_at(plans[0].x, plans[0].y) : -1);
monster_attitude current_attitude = attitude();
if (friendly == 0) {
current_attitude = attitude(&(g->u));
}
// If our plans end in a player, set our attitude to consider that player
if (!plans.empty()) {
if (plans.back().x == g->u.posx && plans.back().y == g->u.posy) {
current_attitude = attitude(&(g->u));
} else {
for (int i = 0; i < g->active_npc.size(); i++) {
if (plans.back().x == g->active_npc[i]->posx &&
plans.back().y == g->active_npc[i]->posy) {
current_attitude = attitude((g->active_npc[i]));
}
}
}
}
if (current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST)) {
moves -= 100;
stumble(false);
return;
}
if (!plans.empty() &&
(mondex == -1 || g->zombie(mondex).friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(plans[0].x, plans[0].y) ||
(plans[0].x == g->u.posx && plans[0].y == g->u.posy) ||
(g->m.has_flag("BASHABLE", plans[0].x, plans[0].y) && has_flag(MF_BASHES)))){
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
plans.clear();
point tmp = scent_move();
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
plans.clear();
point tmp = wander_next();
if (tmp.x != posx() || tmp.y != posy()) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
// Note: The below works because C++ in A() || B() won't call B() if A() is true
int& x = next.x; int& y = next.y; // Define alias for x and y
bool did_something = attack_at(x, y) || bash_at(x, y) || move_to(x, y);
if(!did_something) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
}
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.empty())) ||
!moved) {
stumble(moved);
}
}
point monster::wander_next()
{
point next;
bool xbest = true;
if (abs(wandy - posy()) > abs(wandx - posx()))// which is more important
xbest = false;
next.x = posx();
next.y = posy();
int x = posx(), x2 = posx() - 1, x3 = posx() + 1;
int y = posy(), y2 = posy() - 1, y3 = posy() + 1;
if (wandx < posx()) { x--; x2++; }
if (wandx > posx()) { x++; x2++; x3 -= 2; }
if (wandy < posy()) { y--; y2++; }
if (wandy > posy()) { y++; y2++; y3 -= 2; }
if (xbest) {
if (can_move_to(x, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y))) {
next.x = x;
next.y = y;
} else if (can_move_to(x, y2) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y2))) {
next.x = x;
next.y = y2;
} else if (can_move_to(x2, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x2, y))) {
next.x = x2;
next.y = y;
} else if (can_move_to(x, y3) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y3))) {
next.x = x;
next.y = y3;
} else if (can_move_to(x3, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x3, y))) {
next.x = x3;
next.y = y;
}
} else {
if (can_move_to(x, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y))) {
next.x = x;
next.y = y;
} else if (can_move_to(x2, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x2, y))) {
next.x = x2;
next.y = y;
} else if (can_move_to(x, y2) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y2))) {
next.x = x;
next.y = y2;
} else if (can_move_to(x3, y) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x3, y))) {
next.x = x3;
next.y = y;
} else if (can_move_to(x, y3) || (x == g->u.posx && y == g->u.posy) ||
(has_flag(MF_BASHES) && g->m.has_flag("BASHABLE", x, y3))) {
next.x = x;
next.y = y3;
}
}
return next;
}
void monster::plan(const std::vector<int> &friendlies)
{
int sightrange = g->light_level();
int closest = -1;
int dist = 1000;
int tc = 0;
int stc = 0;
bool fleeing = false;
if (friendly != 0) { // Target monsters, not the player!
for (int i = 0, numz = g->num_zombies(); i < numz; i++) {
monster *tmp = &(g->zombie(i));
if (tmp->friendly == 0) {
int d = rl_dist(posx(), posy(), tmp->posx(), tmp->posy());
if (d < dist && g->m.sees(posx(), posy(), tmp->posx(), tmp->posy(), sightrange, tc)) {
closest = i;
dist = d;
stc = tc;
}
}
}
if (has_effect("docile")) {
closest = -1;
}
if (closest >= 0) {
set_dest(g->zombie(closest).posx(), g->zombie(closest).posy(), stc);
} else if (friendly > 0 && one_in(3)) {
// Grow restless with no targets
friendly--;
} else if (friendly < 0 && sees_player( tc ) ) {
if (rl_dist(posx(), posy(), g->u.posx, g->u.posy) > 2) {
set_dest(g->u.posx, g->u.posy, tc);
} else {
plans.clear();
}
}
return;
}
// If we can see, and we can see a character, move toward them or flee.
if (can_see() && sees_player( tc ) ) {
dist = rl_dist(posx(), posy(), g->u.posx, g->u.posy);
if (is_fleeing(g->u)) {
// Wander away.
fleeing = true;
set_dest(posx() * 2 - g->u.posx, posy() * 2 - g->u.posy, tc);
} else {
// Chase the player.
closest = -2;
stc = tc;
}
}
for (size_t i = 0; i < g->active_npc.size(); i++) {
npc *me = (g->active_npc[i]);
int medist = rl_dist(posx(), posy(), me->posx, me->posy);
if ((medist < dist || (!fleeing && is_fleeing(*me))) &&
(can_see() &&
g->m.sees(posx(), posy(), me->posx, me->posy, sightrange, tc))) {
if (is_fleeing(*me)) {
fleeing = true;
set_dest(posx() * 2 - me->posx, posy() * 2 - me->posy, tc);\
} else {
closest = i;
stc = tc;
}
dist = medist;
}
}
if (!fleeing) {
fleeing = attitude() == MATT_FLEE;
if (can_see()) {
for( auto &friendlie : friendlies ) {
const int i = friendlie;
monster *mon = &(g->zombie(i));
int mondist = rl_dist(posx(), posy(), mon->posx(), mon->posy());
if (mondist < dist &&
g->m.sees(posx(), posy(), mon->posx(), mon->posy(), sightrange, tc)) {
dist = mondist;
if (fleeing) {
wandx = posx() * 2 - mon->posx();
wandy = posy() * 2 - mon->posy();
wandf = 40;
} else {
closest = -3 - i;
stc = tc;
}
}
}
}
if (closest == -2) {
if (one_in(2)) {//random for the diversity of the trajectory
++stc;
} else {
--stc;
}
set_dest(g->u.posx, g->u.posy, stc);
} else if (closest <= -3) {
set_dest(g->zombie(-3 - closest).posx(), g->zombie(-3 - closest).posy(), stc);
} else if (closest >= 0) {
set_dest(g->active_npc[closest]->posx, g->active_npc[closest]->posy, stc);
}
}
// If we're not adjacent to the start of our plan path, don't act on it.
// This is to catch when we had pre-existing invalid plans and
// made it through the function without changing them.
if( !plans.empty() && square_dist(pos().x, pos().y,
plans.front().x, plans.front().y ) > 1 ) {
plans.clear();
}
}
bool Character::move_effects(bool attacking)
{
if (has_effect( effect_downed )) {
///\EFFECT_DEX increases chance to stand up when knocked down
///\EFFECT_STR increases chance to stand up when knocked down, slightly
if (rng(0, 40) > get_dex() + get_str() / 2) {
add_msg_if_player(_("You struggle to stand."));
} else {
add_msg_player_or_npc(m_good, _("You stand up."),
_("<npcname> stands up."));
remove_effect( effect_downed);
}
return false;
}
if (has_effect( effect_webbed )) {
///\EFFECT_STR increases chance to escape webs
if (x_in_y(get_str(), 6 * get_effect_int( effect_webbed ))) {
add_msg_player_or_npc(m_good, _("You free yourself from the webs!"),
_("<npcname> frees themselves from the webs!"));
remove_effect( effect_webbed);
} else {
add_msg_if_player(_("You try to free yourself from the webs, but can't get loose!"));
}
return false;
}
if (has_effect( effect_lightsnare )) {
///\EFFECT_STR increases chance to escape light snare
///\EFFECT_DEX increases chance to escape light snare
if(x_in_y(get_str(), 12) || x_in_y(get_dex(), 8)) {
remove_effect( effect_lightsnare);
add_msg_player_or_npc(m_good, _("You free yourself from the light snare!"),
_("<npcname> frees themselves from the light snare!"));
item string("string_36", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), string);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the light snare, but can't get loose!"));
}
return false;
}
if (has_effect( effect_heavysnare )) {
///\EFFECT_STR increases chance to escape heavy snare, slightly
///\EFFECT_DEX increases chance to escape light snare
if(x_in_y(get_str(), 32) || x_in_y(get_dex(), 16)) {
remove_effect( effect_heavysnare);
add_msg_player_or_npc(m_good, _("You free yourself from the heavy snare!"),
_("<npcname> frees themselves from the heavy snare!"));
item rope("rope_6", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), rope);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the heavy snare, but can't get loose!"));
}
return false;
}
if (has_effect( effect_beartrap )) {
/* Real bear traps can't be removed without the proper tools or immense strength; eventually this should
allow normal players two options: removal of the limb or removal of the trap from the ground
(at which point the player could later remove it from the leg with the right tools).
As such we are currently making it a bit easier for players and NPC's to get out of bear traps.
*/
///\EFFECT_STR increases chance to escape bear trap
if(x_in_y(get_str(), 100)) {
remove_effect( effect_beartrap);
add_msg_player_or_npc(m_good, _("You free yourself from the bear trap!"),
_("<npcname> frees themselves from the bear trap!"));
item beartrap("beartrap", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), beartrap);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the bear trap, but can't get loose!"));
}
return false;
}
if (has_effect( effect_crushed )) {
///\EFFECT_STR increases chance to escape crushing rubble
///\EFFECT_DEX increases chance to escape crushing rubble, slightly
if(x_in_y(get_str() + get_dex() / 4, 100)) {
remove_effect( effect_crushed);
add_msg_player_or_npc(m_good, _("You free yourself from the rubble!"),
_("<npcname> frees themselves from the rubble!"));
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the rubble, but can't get loose!"));
}
return false;
}
// Below this point are things that allow for movement if they succeed
// Currently we only have one thing that forces movement if you succeed, should we get more
// than this will need to be reworked to only have success effects if /all/ checks succeed
if (has_effect( effect_in_pit )) {
///\EFFECT_STR increases chance to escape pit
///\EFFECT_DEX increases chance to escape pit, slightly
if (rng(0, 40) > get_str() + get_dex() / 2) {
add_msg_if_player(m_bad, _("You try to escape the pit, but slip back in."));
return false;
} else {
add_msg_player_or_npc(m_good, _("You escape the pit!"),
_("<npcname> escapes the pit!"));
remove_effect( effect_in_pit);
}
}
if( has_effect( effect_grabbed ) && !attacking ) {
int zed_number = 0;
for( auto &&dest : g->m.points_in_radius( pos(), 1, 0 ) ){
if( g->mon_at( dest ) != -1 &&
( g->zombie( g->mon_at( dest ) ).has_flag( MF_GRABS ) ||
g->zombie( g->mon_at( dest ) ).type->has_special_attack( "GRAB" ) ) ) {
zed_number ++;
}
}
if( zed_number == 0 ) {
add_msg_player_or_npc( m_good, _( "You find yourself no longer grabbed." ),
_( "<npcname> finds themselves no longer grabbed." ) );
remove_effect( effect_grabbed );
///\EFFECT_DEX increases chance to escape grab, if >STR
///\EFFECT_STR increases chance to escape grab, if >DEX
} else if( rng( 0, std::max( get_dex(), get_str() ) ) < rng( get_effect_int( effect_grabbed ), 8 ) ) {
// Randomly compare higher of dex or str to grab intensity.
add_msg_player_or_npc( m_bad, _( "You try break out of the grab, but fail!" ),
_( "<npcname> tries to break out of the grab, but fails!" ) );
return false;
} else {
add_msg_player_or_npc( m_good, _( "You break out of the grab!" ),
_( "<npcname> breaks out of the grab!" ) );
remove_effect( effect_grabbed );
}
}
return Creature::move_effects( attacking );
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move()
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if (wandf > 0) {
wandf--;
}
//Hallucinations have a chance of disappearing each turn
if (is_hallucination() && one_in(25)) {
die( nullptr );
return;
}
//The monster can consume objects it stands on. Check if there are any.
//If there are. Consume them.
if (has_flag(MF_ABSORBS)) {
if(!g->m.i_at(posx(), posy()).empty()) {
add_msg(_("The %s flows around the objects on the floor and they are quickly dissolved!"), name().c_str());
std::vector<item> items_absorbed = g->m.i_at(posx(), posy());
for( auto &elem : items_absorbed ) {
hp += elem.volume(); // Yeah this means it can get more HP than normal.
}
g->m.i_clear(posx(), posy());
}
}
// First, use the special attack, if we can!
for (size_t i = 0; i < sp_timeout.size(); ++i) {
if (sp_timeout[i] > 0) {
sp_timeout[i]--;
}
if( sp_timeout[i] == 0 && (friendly == 0 || has_flag(MF_FRIENDLY_SPECIAL)) &&
!has_effect("pacified") ) {
mattack ma;
if(!is_hallucination()) {
(ma.*type->sp_attack[i])(this, i);
}
}
}
if (moves < 0) {
return;
}
if (!move_effects()) {
moves = 0;
return;
}
if (has_flag(MF_IMMOBILE)) {
moves = 0;
return;
}
if (has_effect("stunned")) {
stumble(false);
moves = 0;
return;
}
if (friendly != 0) {
if (friendly > 0) {
friendly--;
}
friendly_move();
return;
}
bool moved = false;
point next;
int mondex = (!plans.empty() ? g->mon_at(plans[0].x, plans[0].y) : -1);
monster_attitude current_attitude = attitude();
if (friendly == 0) {
current_attitude = attitude(&(g->u));
}
// If our plans end in a player, set our attitude to consider that player
if (!plans.empty()) {
if (plans.back().x == g->u.posx && plans.back().y == g->u.posy) {
current_attitude = attitude(&(g->u));
} else {
for (auto &i : g->active_npc) {
if (plans.back().x == i->posx && plans.back().y == i->posy) {
current_attitude = attitude(i);
}
}
}
}
if (current_attitude == MATT_IGNORE ||
(current_attitude == MATT_FOLLOW && plans.size() <= MONSTER_FOLLOW_DIST)) {
moves -= 100;
stumble(false);
return;
}
if( !plans.empty() &&
(mondex == -1 || g->zombie(mondex).friendly != 0 || has_flag(MF_ATTACKMON)) &&
(can_move_to(plans[0].x, plans[0].y) ||
(plans[0].x == g->u.posx && plans[0].y == g->u.posy) ||
(has_flag(MF_BASHES) &&
g->m.bash_rating(bash_estimate(), plans[0].x, plans[0].y) >= 0) ) ) {
// CONCRETE PLANS - Most likely based on sight
next = plans[0];
moved = true;
} else if (has_flag(MF_SMELLS)) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
plans.clear();
point tmp = scent_move();
if (tmp.x != -1) {
next = tmp;
moved = true;
}
}
if (wandf > 0 && !moved) { // No LOS, no scent, so as a fall-back follow sound
plans.clear();
point tmp = wander_next();
if (tmp.x != posx() || tmp.y != posy()) {
next = tmp;
moved = true;
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if (moved) { // Actual effects of moving to the square we've chosen
// Note: The below works because C++ in A() || B() won't call B() if A() is true
int& x = next.x; int& y = next.y; // Define alias for x and y
bool did_something = attack_at(x, y) || bash_at(x, y) || move_to(x, y);
if(!did_something) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
}
// If we're close to our target, we get focused and don't stumble
if ((has_flag(MF_STUMBLES) && (plans.size() > 3 || plans.empty())) ||
!moved) {
stumble(moved);
}
}
/**
* Attempts to harm a creature with a projectile.
*
* @param source Pointer to the creature who shot the projectile.
* @param missed_by Deviation of the projectile.
* @param proj Reference to the projectile hitting the creature.
* @param dealt_dam A reference storing the damage dealt.
* @return 0 signals that the projectile should stop,
* 1 signals that the projectile should not stop (i.e. dodged, passed through).
*/
int Creature::deal_projectile_attack(Creature *source, double missed_by,
const projectile &proj, dealt_damage_instance &dealt_dam)
{
bool u_see_this = g->u.sees(*this);
body_part bp_hit;
// do 10,speed because speed could potentially be > 10000
if (dodge_roll() >= dice(10, proj.speed)) {
if (is_player())
add_msg(_("You dodge %s projectile!"),
source->disp_name(true).c_str());
else if (u_see_this)
add_msg(_("%s dodges %s projectile."),
disp_name().c_str(), source->disp_name(true).c_str());
return 1;
}
// Bounce applies whether it does damage or not.
if (proj.proj_effects.count("BOUNCE")) {
add_effect("bounced", 1);
}
double hit_value = missed_by + rng_float(-0.5, 0.5);
// headshots considered elsewhere
if (hit_value <= 0.4) {
bp_hit = bp_torso;
} else if (one_in(4)) {
if( one_in(2)) {
bp_hit = bp_leg_l;
} else {
bp_hit = bp_leg_r;
}
} else {
if( one_in(2)) {
bp_hit = bp_arm_l;
} else {
bp_hit = bp_arm_r;
}
}
double monster_speed_penalty = std::max(double(get_speed()) / 80., 1.0);
double goodhit = missed_by / monster_speed_penalty;
double damage_mult = 1.0;
std::string message = "";
game_message_type gmtSCTcolor = m_neutral;
if (goodhit <= .1) {
message = _("Headshot!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_headshot;
damage_mult *= rng_float(2.45, 3.35);
bp_hit = bp_head; // headshot hits the head, of course
} else if (goodhit <= .2) {
message = _("Critical!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_critical;
damage_mult *= rng_float(1.75, 2.3);
} else if (goodhit <= .4) {
message = _("Good hit!");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_good;
damage_mult *= rng_float(1, 1.5);
} else if (goodhit <= .6) {
damage_mult *= rng_float(0.5, 1);
} else if (goodhit <= .8) {
message = _("Grazing hit.");
source->add_msg_if_player(m_good, message.c_str());
gmtSCTcolor = m_grazing;
damage_mult *= rng_float(0, .25);
} else {
damage_mult *= 0;
}
// copy it, since we're mutating
damage_instance impact = proj.impact;
if( item(proj.ammo->id, 0).has_flag("NOGIB") ) {
impact.add_effect("NOGIB");
}
impact.mult_damage(damage_mult);
dealt_dam = deal_damage(source, bp_hit, impact);
dealt_dam.bp_hit = bp_hit;
// Apply ammo effects to target.
const std::string target_material = get_material();
if (proj.proj_effects.count("FLAME")) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood" ) ) {
add_effect("onfire", rng(8, 20));
} else if (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) {
add_effect("onfire", rng(5, 10));
}
} else if (proj.proj_effects.count("INCENDIARY") ) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood") ) {
add_effect("onfire", rng(2, 6));
} else if ( (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) &&
one_in(4) ) {
add_effect("onfire", rng(1, 4));
}
} else if (proj.proj_effects.count("IGNITE")) {
if (0 == target_material.compare("veggy") || 0 == target_material.compare("cotton") ||
0 == target_material.compare("wool") || 0 == target_material.compare("paper") ||
0 == target_material.compare("wood") ) {
add_effect("onfire", rng(6, 6));
} else if (0 == target_material.compare("flesh") || 0 == target_material.compare("iflesh") ) {
add_effect("onfire", rng(10, 10));
}
}
int stun_strength = 0;
if (proj.proj_effects.count("BEANBAG")) {
stun_strength = 4;
}
if(proj.proj_effects.count("WHIP")) {
stun_strength = rng(4, 10);
}
if (proj.proj_effects.count("LARGE_BEANBAG")) {
stun_strength = 16;
}
if( stun_strength > 0 ) {
switch( get_size() ) {
case MS_TINY:
stun_strength *= 4;
break;
case MS_SMALL:
stun_strength *= 2;
break;
case MS_MEDIUM:
default:
break;
case MS_LARGE:
stun_strength /= 2;
break;
case MS_HUGE:
stun_strength /= 4;
break;
}
add_effect( "stunned", rng(stun_strength / 2, stun_strength) );
}
if(u_see_this) {
if (damage_mult == 0) {
if(source != NULL) {
add_msg(source->is_player() ? _("You miss!") : _("The shot misses!"));
}
} else if (dealt_dam.total_damage() == 0) {
add_msg(_("The shot reflects off %s %s!"), disp_name(true).c_str(),
skin_name().c_str());
} else if (source != NULL) {
if (source->is_player()) {
//player hits monster ranged
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(dealt_dam.total_damage(), get_hp_max(), true).first,
m_good, message, gmtSCTcolor);
if (get_hp() > 0) {
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(get_hp(), get_hp_max(), true).first, m_good,
//~ “hit points”, used in scrolling combat text
_("hp"), m_neutral, "hp");
} else {
SCT.removeCreatureHP();
}
add_msg(m_good, _("You hit %s for %d damage."),
disp_name().c_str(), dealt_dam.total_damage());
} else if(this->is_player()) {
//monster hits player ranged
//~ Hit message. 1$s is bodypart name in accusative. 2$d is damage value.
add_msg_if_player(m_bad, _( "You were hit in the %1$s for %2$d damage." ),
body_part_name_accusative(bp_hit).c_str( ),
dealt_dam.total_damage());
} else if( u_see_this ) {
add_msg(_("%s shoots %s."),
source->disp_name().c_str(), disp_name().c_str());
}
}
}
check_dead_state();
return 0;
}
bool Character::move_effects(bool attacking)
{
if (has_effect("downed")) {
if (rng(0, 40) > get_dex() + int(get_str() / 2)) {
add_msg_if_player(_("You struggle to stand."));
} else {
add_msg_player_or_npc(m_good, _("You stand up."),
_("<npcname> stands up."));
remove_effect("downed");
}
return false;
}
if (has_effect("webbed")) {
if (x_in_y(get_str(), 6 * get_effect_int("webbed"))) {
add_msg_player_or_npc(m_good, _("You free yourself from the webs!"),
_("<npcname> frees themselves from the webs!"));
remove_effect("webbed");
} else {
add_msg_if_player(_("You try to free yourself from the webs, but can't get loose!"));
}
return false;
}
if (has_effect("lightsnare")) {
if(x_in_y(get_str(), 12) || x_in_y(get_dex(), 8)) {
remove_effect("lightsnare");
add_msg_player_or_npc(m_good, _("You free yourself from the light snare!"),
_("<npcname> frees themselves from the light snare!"));
item string("string_36", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), string);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the light snare, but can't get loose!"));
}
return false;
}
if (has_effect("heavysnare")) {
if(x_in_y(get_str(), 32) || x_in_y(get_dex(), 16)) {
remove_effect("heavysnare");
add_msg_player_or_npc(m_good, _("You free yourself from the heavy snare!"),
_("<npcname> frees themselves from the heavy snare!"));
item rope("rope_6", calendar::turn);
item snare("snare_trigger", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), rope);
g->m.add_item_or_charges(posx(), posy(), snare);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the heavy snare, but can't get loose!"));
}
return false;
}
if (has_effect("beartrap")) {
/* Real bear traps can't be removed without the proper tools or immense strength; eventually this should
allow normal players two options: removal of the limb or removal of the trap from the ground
(at which point the player could later remove it from the leg with the right tools).
As such we are currently making it a bit easier for players and NPC's to get out of bear traps.
*/
if(x_in_y(get_str(), 100)) {
remove_effect("beartrap");
add_msg_player_or_npc(m_good, _("You free yourself from the bear trap!"),
_("<npcname> frees themselves from the bear trap!"));
item beartrap("beartrap", calendar::turn);
g->m.add_item_or_charges(posx(), posy(), beartrap);
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the bear trap, but can't get loose!"));
}
return false;
}
if (has_effect("crushed")) {
// Strength helps in getting free, but dex also helps you worm your way out of the rubble
if(x_in_y(get_str() + get_dex() / 4, 100)) {
remove_effect("crushed");
add_msg_player_or_npc(m_good, _("You free yourself from the rubble!"),
_("<npcname> frees themselves from the rubble!"));
} else {
add_msg_if_player(m_bad, _("You try to free yourself from the rubble, but can't get loose!"));
}
return false;
}
// Below this point are things that allow for movement if they succeed
// Currently we only have one thing that forces movement if you succeed, should we get more
// than this will need to be reworked to only have success effects if /all/ checks succeed
if (has_effect("in_pit")) {
if (rng(0, 40) > get_str() + int(get_dex() / 2)) {
add_msg_if_player(m_bad, _("You try to escape the pit, but slip back in."));
return false;
} else {
add_msg_player_or_npc(m_good, _("You escape the pit!"),
_("<npcname> escapes the pit!"));
remove_effect("in_pit");
}
}
if (has_effect("grabbed")){
int zed_number = 0;
for( auto &&dest : g->m.points_in_radius( pos(), 1, 0 ) ){
if (g->mon_at(dest) != -1){
zed_number ++;
}
}
if (attacking == true || zed_number == 0){
return true;
}
if (get_dex() > get_str() ? rng(0, get_dex()) : rng( 0, get_str()) < rng( get_effect_int("grabbed") , 8) ){
add_msg_player_or_npc(m_bad, _("You try break out of the grab, but fail!"),
_("<npcname> tries to break out of the grab, but fails!"));
return false;
} else {
add_msg_player_or_npc(m_good, _("You break out of the grab!"),
_("<npcname> breaks out of the grab!"));
remove_effect("grabbed");
}
}
return Creature::move_effects(attacking);
}
/**
* Attempts to harm a creature with a projectile.
*
* @param source Pointer to the creature who shot the projectile.
* @param attack A structure describing the attack and its results.
*/
void Creature::deal_projectile_attack( Creature *source, dealt_projectile_attack &attack )
{
const double missed_by = attack.missed_by;
if( missed_by >= 1.0 ) {
// Total miss
return;
}
const projectile &proj = attack.proj;
dealt_damage_instance &dealt_dam = attack.dealt_dam;
const auto &proj_effects = proj.proj_effects;
const bool u_see_this = g->u.sees(*this);
const int avoid_roll = dodge_roll();
// Do dice(10, speed) instead of dice(speed, 10) because speed could potentially be > 10000
const int diff_roll = dice( 10, proj.speed );
// Partial dodge, capped at [0.0, 1.0], added to missed_by
const double dodge_rescaled = avoid_roll / static_cast<double>( diff_roll );
const double goodhit = missed_by + std::max( 0.0, std::min( 1.0, dodge_rescaled ) ) ;
if( goodhit >= 1.0 ) {
// "Avoid" rather than "dodge", because it includes removing self from the line of fire
// rather than just Matrix-style bullet dodging
if( source != nullptr && g->u.sees( *source ) ) {
add_msg_player_or_npc(
m_warning,
_("You avoid %s projectile!"),
_("<npcname> avoids %s projectile."),
source->disp_name(true).c_str() );
} else {
add_msg_player_or_npc(
m_warning,
_("You avoid an incoming projectile!"),
_("<npcname> avoids an incoming projectile.") );
}
attack.missed_by = 1.0; // Arbitrary value
return;
}
// Bounce applies whether it does damage or not.
if( proj.proj_effects.count( "BOUNCE" ) ) {
add_effect( effect_bounced, 1_turns );
}
body_part bp_hit;
double hit_value = missed_by + rng_float(-0.5, 0.5);
// Headshots considered elsewhere
if( hit_value <= 0.4 ) {
bp_hit = bp_torso;
} else if (one_in(4)) {
if( one_in(2)) {
bp_hit = bp_leg_l;
} else {
bp_hit = bp_leg_r;
}
} else {
if( one_in(2)) {
bp_hit = bp_arm_l;
} else {
bp_hit = bp_arm_r;
}
}
double damage_mult = 1.0;
std::string message = "";
game_message_type gmtSCTcolor = m_neutral;
if( goodhit < accuracy_headshot ) {
message = _("Headshot!");
gmtSCTcolor = m_headshot;
damage_mult *= rng_float(1.95, 2.05);
bp_hit = bp_head; // headshot hits the head, of course
} else if( goodhit < accuracy_critical ) {
message = _("Critical!");
gmtSCTcolor = m_critical;
damage_mult *= rng_float(1.5, 2.0);
} else if( goodhit < accuracy_goodhit ) {
message = _("Good hit!");
gmtSCTcolor = m_good;
damage_mult *= rng_float(1, 1.5);
} else if( goodhit < accuracy_standard ) {
damage_mult *= rng_float(0.5, 1);
} else if( goodhit < accuracy_grazing ) {
message = _("Grazing hit.");
gmtSCTcolor = m_grazing;
damage_mult *= rng_float(0, .25);
}
if( source != nullptr && !message.empty() ) {
source->add_msg_if_player(m_good, message.c_str());
}
attack.missed_by = goodhit;
// copy it, since we're mutating
damage_instance impact = proj.impact;
if( damage_mult > 0.0f && proj_effects.count( "NO_DAMAGE_SCALING" ) ) {
damage_mult = 1.0f;
}
impact.mult_damage(damage_mult);
if( proj_effects.count( "NOGIB" ) > 0 ) {
float dmg_ratio = (float)impact.total_damage() / get_hp_max( player::bp_to_hp( bp_hit ) );
if( dmg_ratio > 1.25f ) {
impact.mult_damage( 1.0f / dmg_ratio );
}
}
dealt_dam = deal_damage(source, bp_hit, impact);
dealt_dam.bp_hit = bp_hit;
// Apply ammo effects to target.
if (proj.proj_effects.count("FLAME")) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, rng( 8_turns, 20_turns ), bp_hit );
} else if (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) {
add_effect( effect_onfire, rng( 5_turns, 10_turns ), bp_hit );
}
} else if (proj.proj_effects.count("INCENDIARY") ) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, rng( 2_turns, 6_turns ), bp_hit );
} else if ( (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) &&
one_in(4) ) {
add_effect( effect_onfire, rng( 1_turns, 4_turns ), bp_hit );
}
} else if (proj.proj_effects.count("IGNITE")) {
if (made_of( material_id( "veggy" ) ) || made_of( material_id( "cotton" ) ) ||
made_of( material_id( "wool" ) ) || made_of( material_id( "paper" ) ) ||
made_of( material_id( "wood" ) ) ) {
add_effect( effect_onfire, 6_turns, bp_hit );
} else if (made_of( material_id( "flesh" ) ) || made_of( material_id( "iflesh" ) ) ) {
add_effect( effect_onfire, 10_turns, bp_hit );
}
}
if( bp_hit == bp_head && proj_effects.count( "BLINDS_EYES" ) ) {
// TODO: Change this to require bp_eyes
add_env_effect( effect_blind, bp_eyes, 5, rng( 3_turns, 10_turns ) );
}
if( proj_effects.count( "APPLY_SAP" ) ) {
add_effect( effect_sap, 1_turns * dealt_dam.total_damage() );
}
int stun_strength = 0;
if (proj.proj_effects.count("BEANBAG")) {
stun_strength = 4;
}
if (proj.proj_effects.count("LARGE_BEANBAG")) {
stun_strength = 16;
}
if( stun_strength > 0 ) {
switch( get_size() ) {
case MS_TINY:
stun_strength *= 4;
break;
case MS_SMALL:
stun_strength *= 2;
break;
case MS_MEDIUM:
default:
break;
case MS_LARGE:
stun_strength /= 2;
break;
case MS_HUGE:
stun_strength /= 4;
break;
}
add_effect( effect_stunned, 1_turns * rng( stun_strength / 2, stun_strength ) );
}
if(u_see_this) {
if( damage_mult == 0 ) {
if( source != nullptr ) {
add_msg( source->is_player() ? _("You miss!") : _("The shot misses!") );
}
} else if( dealt_dam.total_damage() == 0 ) {
//~ 1$ - monster name, 2$ - character's bodypart or monster's skin/armor
add_msg( _("The shot reflects off %1$s %2$s!"), disp_name(true).c_str(),
is_monster() ?
skin_name().c_str() :
body_part_name_accusative(bp_hit).c_str() );
} else if( is_player() ) {
//monster hits player ranged
//~ Hit message. 1$s is bodypart name in accusative. 2$d is damage value.
add_msg_if_player(m_bad, _( "You were hit in the %1$s for %2$d damage." ),
body_part_name_accusative(bp_hit).c_str(),
dealt_dam.total_damage());
} else if( source != nullptr ) {
if( source->is_player() ) {
//player hits monster ranged
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(dealt_dam.total_damage(), get_hp_max(), true).first,
m_good, message, gmtSCTcolor);
if (get_hp() > 0) {
SCT.add(posx(), posy(),
direction_from(0, 0, posx() - source->posx(), posy() - source->posy()),
get_hp_bar(get_hp(), get_hp_max(), true).first, m_good,
//~ "hit points", used in scrolling combat text
_("hp"), m_neutral, "hp");
} else {
SCT.removeCreatureHP();
}
add_msg(m_good, _("You hit %s for %d damage."),
disp_name().c_str(), dealt_dam.total_damage());
} else if( u_see_this ) {
//~ 1$ - shooter, 2$ - target
add_msg(_("%1$s shoots %2$s."),
source->disp_name().c_str(), disp_name().c_str());
}
}
}
check_dead_state();
attack.hit_critter = this;
attack.missed_by = goodhit;
}
int monster::move_to(int x, int y, bool force)
{
// Make sure that we can move there, unless force is true.
if(!force) if(!g->is_empty(x, y) || !can_move_to(x, y)) {
return 0;
}
if (has_effect("beartrap")) {
moves = 0;
return 0;
}
if (!plans.empty()) {
plans.erase(plans.begin());
}
if (!force) {
moves -= calc_movecost(posx(), posy(), x, y);
}
//Check for moving into/out of water
bool was_water = g->m.is_divable(posx(), posy());
bool will_be_water = g->m.is_divable(x, y);
if(was_water && !will_be_water && g->u_see(x, y)) {
//Use more dramatic messages for swimming monsters
add_msg(_("A %s %s from the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("leaps") : _("emerges"),
g->m.tername(posx(), posy()).c_str());
} else if(!was_water && will_be_water && g->u_see(x, y)) {
add_msg(_("A %s %s into the %s!"), name().c_str(),
has_flag(MF_SWIMS) || has_flag(MF_AQUATIC) ? _("dives") : _("sinks"),
g->m.tername(x, y).c_str());
}
setpos(x, y);
footsteps(x, y);
if(is_hallucination()) {
//Hallucinations don't do any of the stuff after this point
return 1;
}
if (type->size != MS_TINY && g->m.has_flag("SHARP", posx(), posy()) && !one_in(4)) {
hurt(rng(2, 3));
}
if (type->size != MS_TINY && g->m.has_flag("ROUGH", posx(), posy()) && one_in(6)) {
hurt(rng(1, 2));
}
if (!digging() && !has_flag(MF_FLIES) &&
g->m.tr_at(posx(), posy()) != tr_null) { // Monster stepped on a trap!
trap* tr = traplist[g->m.tr_at(posx(), posy())];
if (dice(3, type->sk_dodge + 1) < dice(3, tr->avoidance)) {
trapfuncm f;
(f.*(tr->actm))(this, posx(), posy());
}
}
// Diggers turn the dirt into dirtmound
if (digging()){
int factor = 0;
switch (type->size) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if (has_flag(MF_VERMIN)) {
factor *= 100;
}
if (one_in(factor)) {
g->m.ter_set(posx(), posy(), t_dirtmound);
}
}
// Acid trail monsters leave... a trail of acid
if (has_flag(MF_ACIDTRAIL)){
g->m.add_field(posx(), posy(), fd_acid, 3);
}
if (has_flag(MF_SLUDGETRAIL)) {
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
const int fstr = 3 - (abs(dx) + abs(dy));
if (fstr >= 2) {
g->m.add_field(posx() + dx, posy() + dy, fd_sludge, fstr);
}
}
}
}
if (has_flag(MF_LEAKSGAS)){
if (one_in(6)){
g->m.add_field(posx() + rng(-1,1), posy() + rng(-1, 1), fd_toxic_gas, 3);
}
}
return 1;
}
bool monster::digging() const
{
return has_flag(MF_DIGS) || (has_flag(MF_CAN_DIG) && g->m.has_flag("DIGGABLE", posx(), posy()));
}
void monster::knock_back_from(int x, int y)
{
if (x == posx() && y == posy())
return; // No effect
point to(posx(), posy());
if (x < posx())
to.x++;
if (x > posx())
to.x--;
if (y < posy())
to.y++;
if (y > posy())
to.y--;
bool u_see = g->u_see(to.x, to.y);
// First, see if we hit another monster
int mondex = g->mon_at(to.x, to.y);
if (mondex != -1) {
monster *z = &(g->zombie(mondex));
hurt(z->type->size);
add_effect("stunned", 1);
if (type->size > 1 + z->type->size) {
z->knock_back_from(posx(), posy()); // Chain reaction!
z->hurt(type->size);
z->add_effect("stunned", 1);
} else if (type->size > z->type->size) {
z->hurt(type->size);
z->add_effect("stunned", 1);
}
if (u_see)
add_msg(_("The %s bounces off a %s!"), name().c_str(), z->name().c_str());
return;
}
int npcdex = g->npc_at(to.x, to.y);
if (npcdex != -1) {
npc *p = g->active_npc[npcdex];
hurt(3);
add_effect("stunned", 1);
p->hit(this, bp_torso, -1, type->size, 0);
if (u_see)
add_msg(_("The %s bounces off %s!"), name().c_str(), p->name.c_str());
return;
}
// If we're still in the function at this point, we're actually moving a tile!
if (g->m.ter_at(to.x, to.y).has_flag(TFLAG_DEEP_WATER)) {
if (g->m.has_flag("LIQUID", to.x, to.y) && can_drown()) {
hurt(9999);
if (u_see) {
add_msg(_("The %s drowns!"), name().c_str());
}
} else if (has_flag(MF_AQUATIC)) { // We swim but we're NOT in water
hurt(9999);
if (u_see) {
add_msg(_("The %s flops around and dies!"), name().c_str());
}
}
}
if (g->m.move_cost(to.x, to.y) == 0) {
// It's some kind of wall.
hurt(type->size);
add_effect("stunned", 2);
if (u_see) {
add_msg(_("The %s bounces off a %s."), name().c_str(),
g->m.tername(to.x, to.y).c_str());
}
} else { // It's no wall
setpos(to);
}
}
// General movement.
// Currently, priority goes:
// 1) Special Attack
// 2) Sight-based tracking
// 3) Scent-based tracking
// 4) Sound-based tracking
void monster::move()
{
// We decrement wandf no matter what. We'll save our wander_to plans until
// after we finish out set_dest plans, UNLESS they time out first.
if( wandf > 0 ) {
wandf--;
}
//Hallucinations have a chance of disappearing each turn
if( is_hallucination() && one_in( 25 ) ) {
die( nullptr );
return;
}
//The monster can consume objects it stands on. Check if there are any.
//If there are. Consume them.
if( !is_hallucination() && ( has_flag( MF_ABSORBS ) || has_flag( MF_ABSORBS_SPLITS ) ) &&
!g->m.has_flag( TFLAG_SEALED, pos() ) && g->m.has_items( pos() ) ) {
if( g->u.sees( *this ) ) {
add_msg( _( "The %s flows around the objects on the floor and they are quickly dissolved!" ),
name().c_str() );
}
static const auto volume_per_hp = units::from_milliliter( 250 );
for( auto &elem : g->m.i_at( pos() ) ) {
hp += elem.volume() / volume_per_hp; // Yeah this means it can get more HP than normal.
if( has_flag( MF_ABSORBS_SPLITS ) && hp * 2 > type->hp ) {
for( const tripoint &dest : g->m.points_in_radius( pos(), 1 ) ) {
if( g->is_empty( dest ) && hp * 2 > type->hp ) {
if( monster *const spawn = g->summon_mon( type->id, dest ) ) {
hp -= type->hp;
//this is a new copy of the monster. Ideally we should copy the stats/effects that affect the parent
spawn->make_ally( *this );
if( g->u.sees( *this ) ) {
add_msg( _( "The %s splits in two!" ),
name().c_str() );
}
}
}
}
}
}
g->m.i_clear( pos() );
}
const bool pacified = has_effect( effect_pacified );
// First, use the special attack, if we can!
// The attack may change `monster::special_attacks` (e.g. by transforming
// this into another monster type). Therefore we can not iterate over it
// directly and instead iterate over the map from the monster type
// (properties of monster types should never change).
for( const auto &sp_type : type->special_attacks ) {
const std::string &special_name = sp_type.first;
const auto local_iter = special_attacks.find( special_name );
if( local_iter == special_attacks.end() ) {
continue;
}
mon_special_attack &local_attack_data = local_iter->second;
if( !local_attack_data.enabled ) {
continue;
}
// Cooldowns are decremented in monster::process_turn
if( local_attack_data.cooldown == 0 && !pacified && !is_hallucination() ) {
if( !sp_type.second->call( *this ) ) {
continue;
}
// `special_attacks` might have changed at this point. Sadly `reset_special`
// doesn't check the attack name, so we need to do it here.
if( special_attacks.count( special_name ) == 0 ) {
continue;
}
reset_special( special_name );
}
}
// The monster can sometimes hang in air due to last fall being blocked
const bool can_fly = has_flag( MF_FLIES );
if( !can_fly && g->m.has_flag( TFLAG_NO_FLOOR, pos() ) ) {
g->m.creature_on_trap( *this, false );
}
if( moves < 0 ) {
return;
}
// TODO: Move this to attack_at/move_to/etc. functions
bool attacking = false;
if( !move_effects( attacking ) ) {
moves = 0;
return;
}
if( has_flag( MF_IMMOBILE ) ) {
moves = 0;
return;
}
if( has_effect( effect_stunned ) ) {
stumble();
moves = 0;
return;
}
if( friendly > 0 ) {
--friendly;
}
// Set attitude to attitude to our current target
monster_attitude current_attitude = attitude( nullptr );
if( !wander() ) {
if( goal == g->u.pos() ) {
current_attitude = attitude( &( g->u ) );
} else {
for( const npc &guy : g->all_npcs() ) {
if( goal == guy.pos() ) {
current_attitude = attitude( &guy );
}
}
}
}
if( current_attitude == MATT_IGNORE ||
( current_attitude == MATT_FOLLOW && rl_dist( pos(), goal ) <= MONSTER_FOLLOW_DIST ) ) {
moves -= 100;
stumble();
return;
}
bool moved = false;
tripoint destination;
// If true, don't try to greedily avoid locally bad paths
bool pathed = false;
if( !wander() ) {
while( !path.empty() && path.front() == pos() ) {
path.erase( path.begin() );
}
const auto &pf_settings = get_pathfinding_settings();
if( pf_settings.max_dist >= rl_dist( pos(), goal ) &&
( path.empty() || rl_dist( pos(), path.front() ) >= 2 || path.back() != goal ) ) {
// We need a new path
path = g->m.route( pos(), goal, pf_settings, get_path_avoid() );
}
// Try to respect old paths, even if we can't pathfind at the moment
if( !path.empty() && path.back() == goal ) {
destination = path.front();
moved = true;
pathed = true;
} else {
// Straight line forward, probably because we can't pathfind (well enough)
destination = goal;
moved = true;
}
}
if( !moved && has_flag( MF_SMELLS ) ) {
// No sight... or our plans are invalid (e.g. moving through a transparent, but
// solid, square of terrain). Fall back to smell if we have it.
unset_dest();
tripoint tmp = scent_move();
if( tmp.x != -1 ) {
destination = tmp;
moved = true;
}
}
if( wandf > 0 && !moved && friendly == 0 ) { // No LOS, no scent, so as a fall-back follow sound
unset_dest();
if( wander_pos != pos() ) {
destination = wander_pos;
moved = true;
}
}
if( !g->m.has_zlevels() ) {
// Otherwise weird things happen
destination.z = posz();
}
tripoint next_step;
const bool staggers = has_flag( MF_STUMBLES );
const bool can_climb = has_flag( MF_CLIMBS );
if( moved ) {
// Implement both avoiding obstacles and staggering.
moved = false;
float switch_chance = 0.0;
const bool can_bash = bash_skill() > 0;
// This is a float and using trig_dist() because that Does the Right Thing(tm)
// in both circular and roguelike distance modes.
const float distance_to_target = trig_dist( pos(), destination );
for( const tripoint &candidate : squares_closer_to( pos(), destination ) ) {
if( candidate.z != posz() ) {
bool can_z_move = true;
if( !g->m.valid_move( pos(), candidate, false, true ) ) {
// Can't phase through floor
can_z_move = false;
}
// If we're trying to go up but can't fly, check if we can climb. If we can't, then don't
// This prevents non-climb/fly enemies running up walls
if( candidate.z > posz() && !can_fly ) {
if( !can_climb || !g->m.has_floor_or_support( candidate ) ) {
// Can't "jump" up a whole z-level
can_z_move = false;
}
}
// Last chance - we can still do the z-level stair teleport bullshit that isn't removed yet
// @todo: Remove z-level stair bullshit teleport after aligning all stairs
if( !can_z_move &&
posx() / ( SEEX * 2 ) == candidate.x / ( SEEX * 2 ) &&
posy() / ( SEEY * 2 ) == candidate.y / ( SEEY * 2 ) ) {
const tripoint &upper = candidate.z > posz() ? candidate : pos();
const tripoint &lower = candidate.z > posz() ? pos() : candidate;
if( g->m.has_flag( TFLAG_GOES_DOWN, upper ) && g->m.has_flag( TFLAG_GOES_UP, lower ) ) {
can_z_move = true;
}
}
if( !can_z_move ) {
continue;
}
}
// A flag to allow non-stumbling critters to stumble when the most direct choice is bad.
bool bad_choice = false;
const Creature *target = g->critter_at( candidate, is_hallucination() );
if( target != nullptr ) {
const Creature::Attitude att = attitude_to( *target );
if( att == A_HOSTILE ) {
// When attacking an adjacent enemy, we're direct.
moved = true;
next_step = candidate;
break;
} else if( att == A_FRIENDLY && ( target->is_player() || target->is_npc() ) ) {
continue; // Friendly firing the player or an NPC is illegal for gameplay reasons
} else if( !has_flag( MF_ATTACKMON ) && !has_flag( MF_PUSH_MON ) ) {
// Bail out if there's a non-hostile monster in the way and we're not pushy.
continue;
}
// Friendly fire and pushing are always bad choices - they take a lot of time
bad_choice = true;
}
// Bail out if we can't move there and we can't bash.
if( !pathed && !can_move_to( candidate ) ) {
if( !can_bash ) {
continue;
}
const int estimate = g->m.bash_rating( bash_estimate(), candidate );
if( estimate <= 0 ) {
continue;
}
if( estimate < 5 ) {
bad_choice = true;
}
}
const float progress = distance_to_target - trig_dist( candidate, destination );
// The x2 makes the first (and most direct) path twice as likely,
// since the chance of switching is 1/1, 1/4, 1/6, 1/8
switch_chance += progress * 2;
// Randomly pick one of the viable squares to move to weighted by distance.
if( !moved || x_in_y( progress, switch_chance ) ) {
moved = true;
next_step = candidate;
// If we stumble, pick a random square, otherwise take the first one,
// which is the most direct path.
// Except if the direct path is bad, then check others
// Or if the path is given by pathfinder
if( !staggers && ( !bad_choice || pathed ) ) {
break;
}
}
}
}
// Finished logic section. By this point, we should have chosen a square to
// move to (moved = true).
if( moved ) { // Actual effects of moving to the square we've chosen
const bool did_something =
( !pacified && attack_at( next_step ) ) ||
( !pacified && bash_at( next_step ) ) ||
( !pacified && push_to( next_step, 0, 0 ) ) ||
move_to( next_step, false, get_stagger_adjust( pos(), destination, next_step ) );
if( !did_something ) {
moves -= 100; // If we don't do this, we'll get infinite loops.
}
} else {
moves -= 100;
stumble();
path.clear();
}
}
void monster::plan(const std::vector<int> &friendlies)
{
int sightrange = g->light_level();
int closest = -1;
int dist = 1000;
int tc = 0;
int stc = 0;
bool fleeing = false;
if (friendly != 0) { // Target monsters, not the player!
for (int i = 0, numz = g->num_zombies(); i < numz; i++) {
monster *tmp = &(g->zombie(i));
if (tmp->friendly == 0) {
int d = rl_dist(posx(), posy(), tmp->posx(), tmp->posy());
if (d < dist && g->m.sees(posx(), posy(), tmp->posx(), tmp->posy(), sightrange, tc)) {
closest = i;
dist = d;
stc = tc;
}
}
}
if (has_effect("docile")) {
closest = -1;
}
if (closest >= 0) {
set_dest(g->zombie(closest).posx(), g->zombie(closest).posy(), stc);
} else if (friendly > 0 && one_in(3)) {
// Grow restless with no targets
friendly--;
} else if (friendly < 0 && sees_player( tc ) ) {
if (rl_dist(posx(), posy(), g->u.posx, g->u.posy) > 2) {
set_dest(g->u.posx, g->u.posy, tc);
} else {
plans.clear();
}
}
return;
}
// If we can see, and we can see a character, move toward them or flee.
if (can_see() && sees_player( tc ) ) {
dist = rl_dist(posx(), posy(), g->u.posx, g->u.posy);
if (is_fleeing(g->u)) {
// Wander away.
fleeing = true;
set_dest(posx() * 2 - g->u.posx, posy() * 2 - g->u.posy, tc);
} else {
// Chase the player.
closest = -2;
stc = tc;
}
}
for (int i = 0; i < g->active_npc.size(); i++) {
npc *me = (g->active_npc[i]);
int medist = rl_dist(posx(), posy(), me->posx, me->posy);
if ((medist < dist || (!fleeing && is_fleeing(*me))) &&
(can_see() &&
g->m.sees(posx(), posy(), me->posx, me->posy, sightrange, tc))) {
if (is_fleeing(*me)) {
fleeing = true;
set_dest(posx() * 2 - me->posx, posy() * 2 - me->posy, tc);\
} else {
closest = i;
stc = tc;
}
dist = medist;
}
}
if (!fleeing) {
fleeing = attitude() == MATT_FLEE;
if (can_see()) {
for (int f = 0, numf = friendlies.size(); f < numf; f++) {
const int i = friendlies[f];
monster *mon = &(g->zombie(i));
int mondist = rl_dist(posx(), posy(), mon->posx(), mon->posy());
if (mondist < dist &&
g->m.sees(posx(), posy(), mon->posx(), mon->posy(), sightrange, tc)) {
dist = mondist;
if (fleeing) {
wandx = posx() * 2 - mon->posx();
wandy = posy() * 2 - mon->posy();
wandf = 40;
} else {
closest = -3 - i;
stc = tc;
}
}
}
}
if (closest == -2) {
if (one_in(2)) {//random for the diversity of the trajectory
++stc;
} else {
--stc;
}
set_dest(g->u.posx, g->u.posy, stc);
} else if (closest <= -3) {
set_dest(g->zombie(-3 - closest).posx(), g->zombie(-3 - closest).posy(), stc);
} else if (closest >= 0) {
set_dest(g->active_npc[closest]->posx, g->active_npc[closest]->posy, stc);
}
}
}
void monster::plan( const mfactions &factions )
{
// Bots are more intelligent than most living stuff
bool electronic = has_flag( MF_ELECTRONIC );
Creature *target = nullptr;
// 8.6f is rating for tank drone 60 tiles away, moose 16 or boomer 33
float dist = !electronic ? 1000 : 8.6f;
bool fleeing = false;
bool docile = has_flag( MF_VERMIN ) || ( friendly != 0 && has_effect( "docile" ) );
bool angers_hostile_weak = type->anger.find( MTRIG_HOSTILE_WEAK ) != type->anger.end();
int angers_hostile_near = ( type->anger.find( MTRIG_HOSTILE_CLOSE ) != type->anger.end() ) ? 5 : 0;
int fears_hostile_near = ( type->fear.find( MTRIG_HOSTILE_CLOSE ) != type->fear.end() ) ? 5 : 0;
bool group_morale = has_flag( MF_GROUP_MORALE ) && morale < type->morale;
bool swarms = has_flag( MF_SWARMS );
auto mood = attitude();
// If we can see the player, move toward them or flee.
if( friendly == 0 && sees( g->u ) ) {
dist = rate_target( g->u, dist, electronic );
fleeing = fleeing || is_fleeing( g->u );
target = &g->u;
if( dist <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
} else if( friendly != 0 && !docile ) {
// Target unfriendly monsters, only if we aren't interacting with the player.
for( int i = 0, numz = g->num_zombies(); i < numz; i++ ) {
monster &tmp = g->zombie( i );
if( tmp.friendly == 0 ) {
float rating = rate_target( tmp, dist, electronic );
if( rating < dist ) {
target = &tmp;
dist = rating;
}
}
}
}
if( docile ) {
if( friendly != 0 && target != nullptr ) {
set_dest( target->pos() );
}
return;
}
for( size_t i = 0; i < g->active_npc.size(); i++ ) {
npc *me = g->active_npc[i];
float rating = rate_target( *me, dist, electronic );
bool fleeing_from = is_fleeing( *me );
// Switch targets if closer and hostile or scarier than current target
if( ( rating < dist && fleeing ) ||
( rating < dist && attitude( me ) == MATT_ATTACK ) ||
( !fleeing && fleeing_from ) ) {
target = me;
dist = rating;
}
fleeing = fleeing || fleeing_from;
if( rating <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
}
fleeing = fleeing || ( mood == MATT_FLEE );
if( friendly == 0 ) {
for( const auto &fac : factions ) {
auto faction_att = faction.obj().attitude( fac.first );
if( faction_att == MFA_NEUTRAL || faction_att == MFA_FRIENDLY ) {
continue;
}
for( int i : fac.second ) { // mon indices
monster &mon = g->zombie( i );
float rating = rate_target( mon, dist, electronic );
if( rating < dist ) {
target = &mon;
dist = rating;
}
if( rating <= 5 ) {
anger += angers_hostile_near;
morale -= fears_hostile_near;
}
}
}
}
// Friendly monsters here
// Avoid for hordes of same-faction stuff or it could get expensive
const auto actual_faction = friendly == 0 ? faction : mfaction_str_id( "player" );
auto const &myfaction_iter = factions.find( actual_faction );
if( myfaction_iter == factions.end() ) {
DebugLog( D_ERROR, D_GAME ) << disp_name() << " tried to find faction "
<< actual_faction.id().str() << " which wasn't loaded in game::monmove";
swarms = false;
group_morale = false;
}
swarms = swarms && target == nullptr; // Only swarm if we have no target
if( group_morale || swarms ) {
for( const int i : myfaction_iter->second ) {
monster &mon = g->zombie( i );
float rating = rate_target( mon, dist, electronic );
if( group_morale && rating <= 10 ) {
morale += 10 - rating;
}
if( swarms ) {
if( rating < 5 ) { // Too crowded here
wander_pos.x = posx() * rng( 1, 3 ) - mon.posx();
wander_pos.y = posy() * rng( 1, 3 ) - mon.posy();
wandf = 2;
target = nullptr;
// Swarm to the furthest ally you can see
} else if( rating < INT_MAX && rating > dist && wandf <= 0 ) {
target = &mon;
dist = rating;
}
}
}
}
if( target != nullptr ) {
tripoint dest = target->pos();
auto att_to_target = attitude_to( *target );
if( att_to_target == Attitude::A_HOSTILE && !fleeing ) {
set_dest( dest );
} else if( fleeing ) {
set_dest( tripoint( posx() * 2 - dest.x, posy() * 2 - dest.y, posz() ) );
}
if( angers_hostile_weak && att_to_target != Attitude::A_FRIENDLY ) {
int hp_per = target->hp_percentage();
if( hp_per <= 70 ) {
anger += 10 - int( hp_per / 10 );
}
}
} else if( friendly > 0 && one_in( 3 ) ) {
// Grow restless with no targets
friendly--;
} else if( friendly < 0 && sees( g->u ) ) {
if( rl_dist( pos3(), g->u.pos3() ) > 2 ) {
set_dest( g->u.pos3() );
} else {
unset_dest();
}
}
}
void DemoKeeper::createBrickWall( int height, int length, const hkVector4& position, hkReal gapWidth, hkVector4Parameter halfExtents )
{
hkVector4 posx = position;
hkVector4 boxSize(1,1,1);
hkpBoxShape* box = new hkpBoxShape(boxSize,0);
// do a raycast to place the wall
// {
// hkpWorldRayCastInput ray;
// ray.m_from = posx;
// ray.m_to = posx;
//
// ray.m_from(1) += 20.0f;
// ray.m_to(1) -= 20.0f;
//
// hkpWorldRayCastOutput result;
// mWorld->markForWrite();
// mWorld->castRay( ray, result );
//
// posx.setInterpolate4( ray.m_from, ray.m_to, result.m_hitFraction );
// mWorld->unmarkForWrite();
// }
// move the start point
posx(0) -= ( gapWidth + 2.0f * halfExtents(0) ) * length * 0.5f;
posx(1) -= halfExtents(1) + box->getRadius();
hkArray<hkpEntity*> entitiesToAdd;
for ( int x = 0; x < length; x ++ ) // along the ground
{
hkVector4 pos = posx;
for( int ii = 0; ii < height; ii++ )
{
pos(1) += (halfExtents(1) + box->getRadius())* 2.0f;
hkpRigidBodyCinfo boxInfo;
boxInfo.m_mass = 10.0f;
hkMassProperties massProperties;
hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfExtents, boxInfo.m_mass, massProperties);
boxInfo.m_mass = massProperties.m_mass;
boxInfo.m_centerOfMass = massProperties.m_centerOfMass;
boxInfo.m_inertiaTensor = massProperties.m_inertiaTensor;
boxInfo.m_solverDeactivation = boxInfo.SOLVER_DEACTIVATION_MEDIUM;
boxInfo.m_shape = box;
//boxInfo.m_qualityType = HK_COLLIDABLE_QUALITY_DEBRIS;
boxInfo.m_restitution = 0.0f;
boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
{
boxInfo.m_position = pos;
hkpRigidBody* boxRigidBody = new hkpRigidBody(boxInfo);
//render it with Ogre
Ogre::SceneNode* boxNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
boxNode->scale(2,2,2);
Ogre::Entity *ent = mSceneMgr->createEntity(Ogre::StringConverter::toString(mLabMgr->getEntityCount()),"defCube.mesh");
mLabMgr->setColor(ent, Ogre::Vector3(0.5,0.4,0.6));
HkOgre::Renderable* rend = new HkOgre::Renderable(boxNode, boxRigidBody,mWorld);
boxNode->attachObject(ent);
mLabMgr->registerEnity(boxNode, boxRigidBody);
boxRigidBody->setQualityType(HK_COLLIDABLE_QUALITY_BULLET);
mWorld->addEntity( boxRigidBody );
boxRigidBody->removeReference();
}
pos(1) += (halfExtents(1) + box->getRadius())* 2.0f;
pos(0) += halfExtents(0) * 0.6f;
{
boxInfo.m_position = pos;
hkpRigidBody* boxRigidBody = new hkpRigidBody(boxInfo);
//render it with Ogre
Ogre::SceneNode* boxNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
boxNode->scale(2,2,2);
Ogre::Entity *ent = mSceneMgr->createEntity(Ogre::StringConverter::toString(mLabMgr->getEntityCount()),"defCube.mesh");
mLabMgr->setColor(ent, Ogre::Vector3(0.5,0.4,0.6));
HkOgre::Renderable* rend = new HkOgre::Renderable(boxNode, boxRigidBody,mWorld);
boxNode->attachObject(ent);
mLabMgr->registerEnity( boxNode, boxRigidBody);
boxRigidBody->setQualityType(HK_COLLIDABLE_QUALITY_BULLET);
mWorld->addEntity( boxRigidBody );
boxRigidBody->removeReference();
}
pos(0) -= halfExtents(0) * 0.6f;
}
posx(0) += halfExtents(0)* 2.0f + gapWidth;
}
}
bool monster::move_to( const tripoint &p, bool force, float slope )
{
const bool digs = digging();
const bool flies = has_flag( MF_FLIES );
const bool on_ground = !digs && !flies;
const bool climbs = has_flag( MF_CLIMBS ) && g->m.has_flag( TFLAG_NO_FLOOR, p );
// Allows climbing monsters to move on terrain with movecost <= 0
Creature *critter = g->critter_at( p, is_hallucination() );
if( g->m.has_flag( "CLIMBABLE", p ) ) {
if( g->m.move_cost( p ) == 0 && critter == nullptr ) {
if( flies ) {
moves -= 100;
force = true;
if (g->u.sees( *this )){
add_msg(_("The %1$s flies over the %2$s."), name().c_str(),
g->m.has_flag_furn("CLIMBABLE", p) ? g->m.furnname(p).c_str() : g->m.tername(p).c_str());
}
} else if (has_flag(MF_CLIMBS)) {
moves -= 150;
force = true;
if (g->u.sees( *this )){
add_msg(_("The %1$s climbs over the %2$s."), name().c_str(),
g->m.has_flag_furn("CLIMBABLE", p) ? g->m.furnname(p).c_str() : g->m.tername(p).c_str());
}
}
}
}
if( critter != nullptr && !force ) {
return false;
}
// Make sure that we can move there, unless force is true.
if( !force && !can_move_to( p ) ) {
return false;
}
if( !force ) {
// This adjustment is to make it so that monster movement speed relative to the player
// is consistent even if the monster stumbles,
// and the same regardless of the distance measurement mode.
const float stumble_multiplier = has_flag(MF_STUMBLES) ?
(trigdist ? 0.83 : 1.0 - (0.25 * slope)) : 1.0;
const int cost = stumble_multiplier *
(float)(climbs ? calc_climb_cost( pos(), p ) : calc_movecost( pos(), p ));
if( cost > 0 ) {
moves -= cost;
} else {
return false;
}
}
//Check for moving into/out of water
bool was_water = g->m.is_divable( pos3() );
bool will_be_water = on_ground && can_submerge() && g->m.is_divable( p );
if( was_water && !will_be_water && g->u.sees( p ) ) {
//Use more dramatic messages for swimming monsters
add_msg( m_warning, _( "A %1$s %2$s from the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "leaps" ) : _( "emerges" ),
g->m.tername( pos() ).c_str() );
} else if( !was_water && will_be_water && g->u.sees( p ) ) {
add_msg( m_warning, _( "A %1$s %2$s into the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "dives" ) : _( "sinks" ),
g->m.tername( p ).c_str() );
}
setpos( p );
footsteps( p );
underwater = will_be_water;
if( is_hallucination() ) {
//Hallucinations don't do any of the stuff after this point
return true;
}
// TODO: Make tanks stop taking damage from rubble, because it's just silly
if( type->size != MS_TINY && on_ground ) {
if( g->m.has_flag( "SHARP", pos() ) && !one_in( 4 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 10 ) );
}
if( g->m.has_flag( "ROUGH", pos() ) && one_in( 6 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 2 ) );
}
}
if( g->m.has_flag( "UNSTABLE", p ) && on_ground ) {
add_effect( "bouldering", 1, num_bp, true );
} else if( has_effect( "bouldering" ) ) {
remove_effect( "bouldering" );
}
g->m.creature_on_trap( *this );
if( !will_be_water && ( has_flag( MF_DIGS ) || has_flag( MF_CAN_DIG ) ) ) {
underwater = g->m.has_flag( "DIGGABLE", pos() );
}
// Diggers turn the dirt into dirtmound
if( digging() ) {
int factor = 0;
switch( type->size ) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if( has_flag( MF_VERMIN ) ) {
factor *= 100;
}
if( one_in( factor ) ) {
g->m.ter_set( pos(), t_dirtmound );
}
}
// Acid trail monsters leave... a trail of acid
if( has_flag( MF_ACIDTRAIL ) ) {
g->m.add_field( pos(), fd_acid, 3, 0 );
}
if( has_flag( MF_SLUDGETRAIL ) ) {
for( const tripoint &sludge_p : g->m.points_in_radius( pos(), 1 ) ) {
const int fstr = 3 - ( abs( sludge_p.x - posx() ) + abs( sludge_p.y - posy() ) );
if( fstr >= 2 ) {
g->m.add_field( sludge_p, fd_sludge, fstr, 0 );
}
}
}
if( has_flag( MF_LEAKSGAS ) ) {
if( one_in( 6 ) ) {
tripoint dest( posx() + rng( -1, 1 ), posy() + rng( -1, 1 ), posz() );
g->m.add_field( dest, fd_toxic_gas, 3, 0 );
}
}
return true;
}
double modpos(int i, int j)
{
return (pow((posx(i,j)*posx(i,j)+posy(i,j)*posy(i,j)+posz(i,j)*posz(i,j)),0.5));
}
void monster::explode()
{
if( is_hallucination() ) {
//Can't gib hallucinations
return;
}
if( type->has_flag( MF_NOGIB ) || type->has_flag( MF_VERMIN ) ) {
return;
}
// Send body parts and blood all over!
const itype_id meat = type->get_meat_itype();
const field_id type_blood = bloodType();
const field_id type_gib = gibType();
if( meat != "null" || type_blood != fd_null || type_gib != fd_null ) {
// Only create chunks if we know what kind to make.
int num_chunks = 0;
switch( type->size ) {
case MS_TINY:
num_chunks = 1;
break;
case MS_SMALL:
num_chunks = 2;
break;
case MS_MEDIUM:
num_chunks = 4;
break;
case MS_LARGE:
num_chunks = 8;
break;
case MS_HUGE:
num_chunks = 16;
break;
}
for( int i = 0; i < num_chunks; i++ ) {
int tarx = posx() + rng( -3, 3 ), tary = posy() + rng( -3, 3 );
std::vector<point> traj = line_to( posx(), posy(), tarx, tary, 0 );
for( size_t j = 0; j < traj.size(); j++ ) {
tarx = traj[j].x;
tary = traj[j].y;
if( one_in( 2 ) && type_blood != fd_null ) {
g->m.add_field( tarx, tary, type_blood, 1 );
} else if( type_gib != fd_null ) {
g->m.add_field( tarx, tary, type_gib, rng( 1, j + 1 ) );
}
if( g->m.move_cost( tarx, tary ) == 0 ) {
if( !g->m.bash( tarx, tary, 3 ).second ) {
// Target is obstacle, not destroyed by bashing,
// stop trajectory in front of it, if this is the first
// point (e.g. wall adjacent to monster) , make it invalid.
if( j > 0 ) {
tarx = traj[j - 1].x;
tary = traj[j - 1].y;
} else {
tarx = -1;
}
break;
}
}
}
if( meat != "null" && tarx != -1 ) {
g->m.spawn_item( tarx, tary, meat, 1, 0, calendar::turn );
}
}
}
}
double fx(int i, int j) //acceleration on i due to j, x component
{
return (G*m[j]*posx(i,j)/pow(modpos(i,j),3));
}
void monster::process_effects()
{
// Monster only effects
int mod = 1;
for( auto &elem : effects ) {
for( auto &_effect_it : elem.second ) {
auto &it = _effect_it.second;
// Monsters don't get trait-based reduction, but they do get effect based reduction
bool reduced = has_effect(it.get_resist_effect());
mod_speed_bonus(it.get_mod("SPEED", reduced));
int val = it.get_mod("HURT", reduced);
if (val > 0) {
if(it.activated(calendar::turn, "HURT", val, reduced, mod)) {
apply_damage(nullptr, bp_torso, val);
}
}
std::string id = _effect_it.second.get_id();
// MATERIALS-TODO: use fire resistance
if (id == "onfire") {
if (made_of("flesh") || made_of("iflesh"))
apply_damage( nullptr, bp_torso, rng( 3, 8 ) );
if (made_of("veggy"))
apply_damage( nullptr, bp_torso, rng( 10, 20 ) );
if (made_of("paper") || made_of("powder") || made_of("wood") || made_of("cotton") ||
made_of("wool"))
apply_damage( nullptr, bp_torso, rng( 15, 40 ) );
}
}
}
//If this monster has the ability to heal in combat, do it now.
if( has_flag( MF_REGENERATES_50 ) ) {
if( hp < type->hp ) {
if( one_in( 2 ) && g->u.sees( *this ) ) {
add_msg( m_warning, _( "The %s is visibly regenerating!" ), name().c_str() );
}
hp += 50;
if( hp > type->hp ) {
hp = type->hp;
}
}
}
if( has_flag( MF_REGENERATES_10 ) ) {
if( hp < type->hp ) {
if( one_in( 2 ) && g->u.sees( *this ) ) {
add_msg( m_warning, _( "The %s seems a little healthier." ), name().c_str() );
}
hp += 10;
if( hp > type->hp ) {
hp = type->hp;
}
}
}
//Monster will regen morale and aggression if it is on max HP
//It regens more morale and aggression if is currently fleeing.
if( has_flag( MF_REGENMORALE ) && hp >= type->hp ) {
if( is_fleeing( g->u ) ) {
morale = type->morale;
anger = type->agro;
}
if( morale <= type->morale ) {
morale += 1;
}
if( anger <= type->agro ) {
anger += 1;
}
if( morale < 0 ) {
morale += 5;
}
if( anger < 0 ) {
anger += 5;
}
}
// If this critter dies in sunlight, check & assess damage.
if( has_flag( MF_SUNDEATH ) && g->is_in_sunlight( posx(), posy() ) ) {
if( g->u.sees( *this ) ) {
add_msg( m_good, _( "The %s burns horribly in the sunlight!" ), name().c_str() );
}
apply_damage( nullptr, bp_torso, 100 );
if( hp < 0 ) {
hp = 0;
}
}
Creature::process_effects();
}
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;
}
void player::activate_mutation( const std::string &mut )
{
const auto &mdata = mutation_branch::get( mut );
auto &tdata = my_mutations[mut];
int cost = mdata.cost;
// You can take yourself halfway to Near Death levels of hunger/thirst.
// Fatigue can go to Exhausted.
if ((mdata.hunger && get_hunger() >= 700) || (mdata.thirst && get_thirst() >= 260) ||
(mdata.fatigue && get_fatigue() >= EXHAUSTED)) {
// Insufficient Foo to *maintain* operation is handled in player::suffer
add_msg_if_player(m_warning, _("You feel like using your %s would kill you!"), mdata.name.c_str());
return;
}
if (tdata.powered && tdata.charge > 0) {
// Already-on units just lose a bit of charge
tdata.charge--;
} else {
// Not-on units, or those with zero charge, have to pay the power cost
if (mdata.cooldown > 0) {
tdata.charge = mdata.cooldown - 1;
}
if (mdata.hunger){
mod_hunger(cost);
}
if (mdata.thirst){
mod_thirst(cost);
}
if (mdata.fatigue){
mod_fatigue(cost);
}
tdata.powered = true;
// Handle stat changes from activation
apply_mods(mut, true);
recalc_sight_limits();
}
if( mut == "WEB_WEAVER" ) {
g->m.add_field(pos(), fd_web, 1, 0);
add_msg_if_player(_("You start spinning web with your spinnerets!"));
} else if (mut == "BURROW"){
if( is_underwater() ) {
add_msg_if_player(m_info, _("You can't do that while underwater."));
tdata.powered = false;
return;
}
tripoint dirp;
if (!choose_adjacent(_("Burrow where?"), dirp)) {
tdata.powered = false;
return;
}
if( dirp == pos() ) {
add_msg_if_player(_("You've got places to go and critters to beat."));
add_msg_if_player(_("Let the lesser folks eat their hearts out."));
tdata.powered = false;
return;
}
int turns;
if (g->m.is_bashable(dirp) && g->m.has_flag("SUPPORTS_ROOF", dirp) &&
g->m.ter(dirp) != t_tree) {
// Takes about 100 minutes (not quite two hours) base time.
// Being better-adapted to the task means that skillful Survivors can do it almost twice as fast.
///\EFFECT_CARPENTRY speeds up burrowing
turns = (100000 - 5000 * skillLevel( skill_id( "carpentry" ) ));
} else if (g->m.move_cost(dirp) == 2 && g->get_levz() == 0 &&
g->m.ter(dirp) != t_dirt && g->m.ter(dirp) != t_grass) {
turns = 18000;
} else {
add_msg_if_player(m_info, _("You can't burrow there."));
tdata.powered = false;
return;
}
assign_activity(ACT_BURROW, turns, -1, 0);
activity.placement = dirp;
add_msg_if_player(_("You tear into the %s with your teeth and claws."),
g->m.tername(dirp).c_str());
tdata.powered = false;
return; // handled when the activity finishes
} else if (mut == "SLIMESPAWNER") {
std::vector<tripoint> valid;
for (int x = posx() - 1; x <= posx() + 1; x++) {
for (int y = posy() - 1; y <= posy() + 1; y++) {
tripoint dest(x, y, posz());
if (g->is_empty(dest)) {
valid.push_back( dest );
}
}
}
// Oops, no room to divide!
if (valid.size() == 0) {
add_msg_if_player(m_bad, _("You focus, but are too hemmed in to birth a new slimespring!"));
tdata.powered = false;
return;
}
add_msg_if_player(m_good, _("You focus, and with a pleasant splitting feeling, birth a new slimespring!"));
int numslime = 1;
for (int i = 0; i < numslime && !valid.empty(); i++) {
const tripoint target = random_entry_removed( valid );
if (g->summon_mon(mtype_id( "mon_player_blob" ), target)) {
monster *slime = g->monster_at( target );
slime->friendly = -1;
}
}
if (one_in(3)) {
//~ Usual enthusiastic slimespring small voices! :D
add_msg_if_player(m_good, _("wow! you look just like me! we should look out for each other!"));
} else if (one_in(2)) {
//~ Usual enthusiastic slimespring small voices! :D
add_msg_if_player(m_good, _("come on, big me, let's go!"));
} else {
//~ Usual enthusiastic slimespring small voices! :D
add_msg_if_player(m_good, _("we're a team, we've got this!"));
}
tdata.powered = false;
return;
} else if ((mut == "NAUSEA") || (mut == "VOMITOUS") ){
vomit();
tdata.powered = false;
return;
} else if (mut == "M_FERTILE"){
spores();
tdata.powered = false;
return;
} else if (mut == "M_BLOOM"){
blossoms();
tdata.powered = false;
return;
} else if (mut == "VINES3"){
item newit( "vine_30", calendar::turn );
if (!can_pickVolume(newit.volume())) { //Accounts for result_mult
add_msg_if_player(_("You detach a vine but don't have room to carry it, so you drop it."));
g->m.add_item_or_charges(pos(), newit);
} else if (!can_pickWeight(newit.weight(), !OPTIONS["DANGEROUS_PICKUPS"])) {
add_msg_if_player(_("Your freshly-detached vine is too heavy to carry, so you drop it."));
g->m.add_item_or_charges(pos(), newit);
} else {
inv.assign_empty_invlet(newit);
newit = i_add(newit);
add_msg_if_player(m_info, "%c - %s", newit.invlet == 0 ? ' ' : newit.invlet, newit.tname().c_str());
}
tdata.powered = false;
return;
} else if( mut == "SELFAWARE" ) {
print_health();
tdata.powered = false;
return;
}
}
int main(int argc, char *argv[])
{
int time_limit;
char name[1000];
ListGraph g;
EdgeWeight lpvar(g);
EdgeWeight weight(g);
NodeName vname(g);
ListGraph::NodeMap<double> posx(g),posy(g);
string filename;
int seed=1;
// uncomment one of these lines to change default pdf reader, or insert new one
//set_pdfreader("open"); // pdf reader for Mac OS X
//set_pdfreader("xpdf"); // pdf reader for Linux
//set_pdfreader("evince"); // pdf reader for Linux
srand48(seed);
time_limit = 3600; // solution must be obtained within time_limit seconds
if (argc!=2) {cout<< endl << "Usage: "<< argv[0]<<" <graph_filename>"<<endl << endl <<
"Example: " << argv[0] << " gr_berlin52" << endl <<
" " << argv[0] << " gr_att48" << endl << endl; exit(0);}
else if (!FileExists(argv[1])) {cout<<"File "<<argv[1]<<" does not exist."<<endl; exit(0);}
filename = argv[1];
// Read the graph
if (!ReadListGraph(filename,g,vname,weight,posx,posy))
{cout<<"Error reading graph file "<<argv[1]<<"."<<endl;exit(0);}
TSP_Data tsp(g,vname,posx,posy,weight);
ListGraph::EdgeMap<GRBVar> x(g);
GRBEnv env = GRBEnv();
GRBModel model = GRBModel(env);
#if GUROBI_NEWVERSION
model.getEnv().set(GRB_IntParam_LazyConstraints, 1);
model.getEnv().set(GRB_IntParam_Seed, seed);
#else
model.getEnv().set(GRB_IntParam_DualReductions, 0); // Dual reductions must be disabled when using lazy constraints
#endif
model.set(GRB_StringAttr_ModelName, "Emparelhamento perfeito with GUROBI");
// name to the problem
model.set(GRB_IntAttr_ModelSense, GRB_MAXIMIZE); // is a minimization problem
// Add one binary variable for each edge and also sets its cost in
//the objective function
for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {
sprintf(name,"x_%s_%s",vname[g.u(e)].c_str(),vname[g.v(e)].c_str());
x[e] = model.addVar(0.0, 1.0, weight[e],GRB_BINARY,name);
}
model.update(); // run update to use model inserted variables
// Add degree constraint for each node (sum of solution edges incident to a node is 2)
for (ListGraph::NodeIt v(g); v!=INVALID; ++v) {
GRBLinExpr expr;
for (ListGraph::IncEdgeIt e(g,v); e!=INVALID; ++e) expr += x[e];
//aqui model.addConstr(expr == 2 ); what? ignorou!
model.addConstr(expr == 1);
}
try {
model.update(); // Process any pending model modifications.
if (time_limit >= 0) model.getEnv().set(GRB_DoubleParam_TimeLimit,time_limit);
model.update(); // Process any pending model modifications.
model.write("model.lp");
system("cat model.lp");
model.optimize();
double soma=0.0;
int i = 0;
for (ListGraph::EdgeIt e(g); e!=INVALID; ++e) {
lpvar[e] = x[e].get(GRB_DoubleAttr_X);
if (lpvar[e] > 1-BC_EPS ) {
soma += weight[e];
cout << "Achei, x("<< vname[g.u(e)] << " , " << vname[g.v(e)] << ") = " << lpvar[e] <<"\n";
tsp.BestCircuit[i] = g.u(e);
tsp.BestCircuit[i+1] = g.v(e);
i = i+2;
}
}
cout << "Solution cost = "<< soma << endl;
ViewTspCircuit(tsp);
}catch (...) {
if (tsp.BestCircuitValue < DBL_MAX) {
cout << "Heuristic obtained optimum solution" << endl;
ViewTspCircuit(tsp);
return 0;
}else {
cout << "Graph is infeasible" << endl;
return 1;
}
}
}
