// Copyright (c) ZeniMax Media Inc. // Licensed under the GNU General Public License 2.0. // g_ai.c #include "g_local.h" bool FindTarget(edict_t *self); bool ai_checkattack(edict_t *self, float dist); bool enemy_vis; bool enemy_infront; float enemy_yaw; // ROGUE constexpr float MAX_SIDESTEP = 8.0f; // ROGUE //============================================================================ /* ================= AI_GetSightClient For a given monster, check active players to see who we can see. We don't care who we see, as long as it's something we can shoot. ================= */ edict_t *AI_GetSightClient(edict_t *self) { if (level.intermissiontime) return nullptr; edict_t **visible_players = (edict_t **) alloca(sizeof(edict_t *) * game.maxclients); size_t num_visible = 0; for (auto player : active_players()) { if (player->health <= 0 || player->deadflag || !player->solid) continue; else if (player->flags & (FL_NOTARGET | FL_DISGUISED)) continue; // if we're touching them, allow to pass through if (!boxes_intersect(self->absmin, self->absmax, player->absmin, player->absmax)) { if ((!(self->monsterinfo.aiflags & AI_THIRD_EYE) && !infront(self, player)) || !visible(self, player)) continue; } visible_players[num_visible++] = player; // got one } if (!num_visible) return nullptr; return visible_players[irandom(num_visible)]; } //============================================================================ /* ============= ai_move Move the specified distance at current facing. This replaces the QC functions: ai_forward, ai_back, ai_pain, and ai_painforward ============== */ void ai_move(edict_t *self, float dist) { M_walkmove(self, self->s.angles[YAW], dist); } /* ============= ai_stand Used for standing around and looking for players Distance is for slight position adjustments needed by the animations ============== */ void ai_stand(edict_t *self, float dist) { vec3_t v; // ROGUE bool retval; // ROGUE if (dist || (self->monsterinfo.aiflags & AI_ALTERNATE_FLY)) M_walkmove(self, self->s.angles[YAW], dist); if (self->monsterinfo.aiflags & AI_STAND_GROUND) { // [Paril-KEX] check if we've been pushed out of our point_combat if (!(self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND) && self->movetarget && self->movetarget->classname && !strcmp(self->movetarget->classname, "point_combat")) { if (!boxes_intersect(self->absmin, self->absmax, self->movetarget->absmin, self->movetarget->absmax)) { self->monsterinfo.aiflags &= ~AI_STAND_GROUND; self->monsterinfo.aiflags |= AI_COMBAT_POINT; self->goalentity = self->movetarget; self->monsterinfo.run(self); return; } } if (self->enemy && !(self->enemy->classname && !strcmp(self->enemy->classname, "player_noise"))) { v = self->enemy->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(v); if (!FacingIdeal(self) && (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND)) { self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); self->monsterinfo.run(self); } // ROGUE if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) // ROGUE M_ChangeYaw(self); // find out if we're going to be shooting retval = ai_checkattack(self, 0); // record sightings of player if ((self->enemy) && (self->enemy->inuse)) { if (visible(self, self->enemy)) { self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; self->monsterinfo.last_sighting = self->monsterinfo.saved_goal = self->enemy->s.origin; self->monsterinfo.blind_fire_target = self->monsterinfo.last_sighting + (self->enemy->velocity * -0.1f); self->monsterinfo.trail_time = level.time; self->monsterinfo.blind_fire_delay = 0_ms; } else { if (FindTarget(self)) return; self->monsterinfo.aiflags |= AI_LOST_SIGHT; } // Paril: fixes rare cases of a stand ground monster being stuck // aiming at a sound target that they can still see if ((self->monsterinfo.aiflags & AI_SOUND_TARGET) && !retval) { if (FindTarget(self)) return; } } // check retval to make sure we're not blindfiring else if (!retval) { FindTarget(self); return; } // ROGUE } else FindTarget(self); return; } // Paril: this fixes a bug somewhere else that sometimes causes // a monster to be given an enemy without ever calling HuntTarget. if (self->enemy && !(self->monsterinfo.aiflags & AI_SOUND_TARGET)) { HuntTarget(self); return; } if (FindTarget(self)) return; if (level.time > self->monsterinfo.pausetime) { self->monsterinfo.walk(self); return; } if (!(self->spawnflags & SPAWNFLAG_MONSTER_AMBUSH) && (self->monsterinfo.idle) && (level.time > self->monsterinfo.idle_time)) { if (self->monsterinfo.idle_time) { self->monsterinfo.idle(self); self->monsterinfo.idle_time = level.time + random_time(15_sec, 30_sec); } else { self->monsterinfo.idle_time = level.time + random_time(15_sec); } } } /* ============= ai_walk The monster is walking it's beat ============= */ void ai_walk(edict_t *self, float dist) { edict_t *temp_goal = nullptr; if (!self->goalentity && (self->monsterinfo.aiflags & AI_GOOD_GUY)) { vec3_t fwd; AngleVectors(self->s.angles, fwd, nullptr, nullptr); temp_goal = G_Spawn(); temp_goal->s.origin = self->s.origin + fwd * 64; self->goalentity = temp_goal; } M_MoveToGoal(self, dist); if (temp_goal) { G_FreeEdict(temp_goal); self->goalentity = nullptr; } // check for noticing a player if (FindTarget(self)) return; if ((self->monsterinfo.search) && (level.time > self->monsterinfo.idle_time)) { if (self->monsterinfo.idle_time) { self->monsterinfo.search(self); self->monsterinfo.idle_time = level.time + random_time(15_sec, 30_sec); } else { self->monsterinfo.idle_time = level.time + random_time(15_sec); } } } /* ============= ai_charge Turns towards target and advances Use this call with a distance of 0 to replace ai_face ============== */ void ai_charge(edict_t *self, float dist) { vec3_t v; // ROGUE float ofs; // PMM - made AI_MANUAL_STEERING affect things differently here .. they turn, but // don't set the ideal_yaw // This is put in there so monsters won't move towards the origin after killing // a tesla. This could be problematic, so keep an eye on it. if (!self->enemy || !self->enemy->inuse) // PGM return; // PGM // PMM - save blindfire target if (visible(self, self->enemy)) self->monsterinfo.blind_fire_target = self->enemy->s.origin + (self->enemy->velocity * -0.1f); // pmm if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) { // ROGUE v = self->enemy->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(v); // ROGUE } // ROGUE M_ChangeYaw(self); if (dist || (self->monsterinfo.aiflags & AI_ALTERNATE_FLY)) // ROGUE { if (self->monsterinfo.aiflags & AI_CHARGING) { M_MoveToGoal(self, dist); return; } // circle strafe support if (self->monsterinfo.attack_state == AS_SLIDING) { // if we're fighting a tesla, NEVER circle strafe if ((self->enemy) && (self->enemy->classname) && (!strcmp(self->enemy->classname, "tesla_mine"))) ofs = 0; else if (self->monsterinfo.lefty) ofs = 90; else ofs = -90; dist *= self->monsterinfo.active_move->sidestep_scale; if (M_walkmove(self, self->ideal_yaw + ofs, dist)) return; self->monsterinfo.lefty = !self->monsterinfo.lefty; M_walkmove(self, self->ideal_yaw - ofs, dist); } else // ROGUE M_walkmove(self, self->s.angles[YAW], dist); // ROGUE } // ROGUE // [Paril-KEX] if our enemy is literally right next to us, give // us more rotational speed so we don't get circled if (range_to(self, self->enemy) <= RANGE_MELEE * 2.5f) M_ChangeYaw(self); } /* ============= ai_turn don't move, but turn towards ideal_yaw Distance is for slight position adjustments needed by the animations ============= */ void ai_turn(edict_t *self, float dist) { if (dist || (self->monsterinfo.aiflags & AI_ALTERNATE_FLY)) M_walkmove(self, self->s.angles[YAW], dist); if (FindTarget(self)) return; // ROGUE if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) // ROGUE M_ChangeYaw(self); } /* .enemy Will be world if not currently angry at anyone. .movetarget The next path spot to walk toward. If .enemy, ignore .movetarget. When an enemy is killed, the monster will try to return to it's path. .hunt_time Set to time + something when the player is in sight, but movement straight for him is blocked. This causes the monster to use wall following code for movement direction instead of sighting on the player. .ideal_yaw A yaw angle of the intended direction, which will be turned towards at up to 45 deg / state. If the enemy is in view and hunt_time is not active, this will be the exact line towards the enemy. .pausetime A monster will leave it's stand state and head towards it's .movetarget when time > .pausetime. walkmove(angle, speed) primitive is all or nothing */ /* ============= range_to returns the distance of an entity relative to self. in general, the results determine how an AI reacts: melee melee range, will become hostile even if back is turned near visibility and infront, or visibility and show hostile mid infront and show hostile > mid only triggered by damage ============= */ float range_to(edict_t *self, edict_t *other) { return distance_between_boxes(self->absmin, self->absmax, other->absmin, other->absmax); } /* ============= visible returns 1 if the entity is visible to self, even if not infront () ============= */ bool visible(edict_t *self, edict_t *other, bool through_glass) { // never visible if (other->flags & FL_NOVISIBLE) return false; // [Paril-KEX] bit of a hack, but we'll tweak monster-player visibility // if they have the invisibility powerup. if (other->client) { // always visible in rtest if (self->hackflags & HACKFLAG_ATTACK_PLAYER) return self->inuse; // fix intermission if (!other->solid) return false; if (other->client->invisible_time > level.time) { // can't see us at all after this time if (other->client->invisibility_fade_time <= level.time) return false; // otherwise, throw in some randomness if (frandom() > other->s.alpha) return false; } } vec3_t spot1; vec3_t spot2; trace_t trace; spot1 = self->s.origin; spot1[2] += self->viewheight; spot2 = other->s.origin; spot2[2] += other->viewheight; contents_t mask = MASK_OPAQUE; if (!through_glass) mask |= CONTENTS_WINDOW; trace = gi.traceline(spot1, spot2, self, mask); return trace.fraction == 1.0f || trace.ent == other; // PGM } /* ============= infront returns 1 if the entity is in front (in sight) of self ============= */ bool infront(edict_t *self, edict_t *other) { vec3_t vec; float dot; vec3_t forward; AngleVectors(self->s.angles, forward, nullptr, nullptr); vec = other->s.origin - self->s.origin; vec.normalize(); dot = vec.dot(forward); // [Paril-KEX] if we're an ambush monster, reduce our cone of // vision to not ruin surprises, unless we already had an enemy. if (self->spawnflags.has(SPAWNFLAG_MONSTER_AMBUSH) && !self->monsterinfo.trail_time && !self->enemy) return dot > 0.15f; return dot > -0.30f; } //============================================================================ void HuntTarget(edict_t *self, bool animate_state) { vec3_t vec; self->goalentity = self->enemy; if (animate_state) { if (self->monsterinfo.aiflags & AI_STAND_GROUND) self->monsterinfo.stand(self); else self->monsterinfo.run(self); } vec = self->enemy->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(vec); } void FoundTarget(edict_t *self) { // let other monsters see this monster for a while if (self->enemy->client) { // ROGUE if (self->enemy->flags & FL_DISGUISED) self->enemy->flags &= ~FL_DISGUISED; // ROGUE self->enemy->client->sight_entity = self; self->enemy->client->sight_entity_time = level.time; self->enemy->show_hostile = level.time + 1_sec; // wake up other monsters } // [Paril-KEX] the first time we spot something, give us a bit of a grace // period on firing if (!self->monsterinfo.trail_time) self->monsterinfo.attack_finished = level.time + 600_ms; // give easy/medium a little more reaction time self->monsterinfo.attack_finished += skill->integer == 0 ? 400_ms : skill->integer == 1 ? 200_ms : 0_ms; self->monsterinfo.last_sighting = self->monsterinfo.saved_goal = self->enemy->s.origin; self->monsterinfo.trail_time = level.time; // ROGUE self->monsterinfo.blind_fire_target = self->monsterinfo.last_sighting + (self->enemy->velocity * -0.1f); self->monsterinfo.blind_fire_delay = 0_ms; // ROGUE // [Paril-KEX] for alternate fly, pick a new position immediately self->monsterinfo.fly_position_time = 0_ms; self->monsterinfo.aiflags &= ~AI_THIRD_EYE; // Paril: if we're heading to a combat point/path corner, don't // hunt the new target yet. if (self->monsterinfo.aiflags & AI_COMBAT_POINT) return; if (!self->combattarget) { HuntTarget(self); return; } self->goalentity = self->movetarget = G_PickTarget(self->combattarget); if (!self->movetarget) { self->goalentity = self->movetarget = self->enemy; HuntTarget(self); gi.Com_PrintFmt("{}: combattarget {} not found\n", *self, self->combattarget); return; } // clear out our combattarget, these are a one shot deal self->combattarget = nullptr; self->monsterinfo.aiflags |= AI_COMBAT_POINT; // clear the targetname, that point is ours! // [Paril-KEX] not any more, we can re-use them //self->movetarget->targetname = nullptr; self->monsterinfo.pausetime = 0_ms; // run for it self->monsterinfo.run(self); } // [Paril-KEX] monsters that were alerted by players will // be temporarily stored on player entities, so we can // check them & get mad at them even around corners static edict_t *AI_GetMonsterAlertedByPlayers(edict_t *self) { for (auto player : active_players()) { // dead if (player->health <= 0 || player->deadflag || !player->solid) continue; // we didn't alert any other monster, or it wasn't recently if (!player->client->sight_entity || !(player->client->sight_entity_time >= (level.time - FRAME_TIME_S))) continue; // if we can't see the monster, don't bother if (!visible(self, player->client->sight_entity)) continue; // probably good return player->client->sight_entity; } return nullptr; } // [Paril-KEX] per-player sounds static edict_t *AI_GetSoundClient(edict_t *self, bool direct) { edict_t *best_sound = nullptr; float best_distance = std::numeric_limits::max(); for (auto player : active_players()) { // dead if (player->health <= 0 || player->deadflag || !player->solid) continue; edict_t *sound = direct ? player->client->sound_entity : player->client->sound2_entity; if (!sound) continue; // too late gtime_t &time = direct ? player->client->sound_entity_time : player->client->sound2_entity_time; if (!(time >= (level.time - FRAME_TIME_S))) continue; // prefer the closest one we heard float dist = (self->s.origin - sound->s.origin).length(); if (!best_sound || dist < best_distance) { best_distance = dist; best_sound = sound; } } return best_sound; } bool G_MonsterSourceVisible(edict_t *self, edict_t *client) { // this is where we would check invisibility float r = range_to(self, client); if (r > RANGE_MID) return false; // Paril: revised so that monsters can be woken up // by players 'seen' and attacked at by other monsters // if they are close enough. they don't have to be visible. bool is_visible = ((r <= RANGE_NEAR && client->show_hostile >= level.time && !(self->spawnflags & SPAWNFLAG_MONSTER_AMBUSH)) || (visible(self, client) && (r <= RANGE_MELEE || (self->monsterinfo.aiflags & AI_THIRD_EYE) || infront(self, client)))); return is_visible; } /* =========== FindTarget Self is currently not attacking anything, so try to find a target Returns TRUE if an enemy was sighted When a player fires a missile, the point of impact becomes a fakeplayer so that monsters that see the impact will respond as if they had seen the player. To avoid spending too much time, only a single client (or fakeclient) is checked each frame. This means multi player games will have slightly slower noticing monsters. ============ */ bool FindTarget(edict_t *self) { edict_t *client = nullptr; bool heardit; bool ignore_sight_sound = false; // [Paril-KEX] if we're in a level transition, don't worry about enemies if (globals.server_flags & SERVER_FLAG_LOADING) return false; // N64 cutscene behavior if (self->hackflags & HACKFLAG_END_CUTSCENE) return false; if (self->monsterinfo.aiflags & AI_GOOD_GUY) { if (self->goalentity && self->goalentity->inuse && self->goalentity->classname) { if (strcmp(self->goalentity->classname, "target_actor") == 0) return false; } // FIXME look for monsters? return false; } // if we're going to a combat point, just proceed if (self->monsterinfo.aiflags & AI_COMBAT_POINT) return false; // if the first spawnflag bit is set, the monster will only wake up on // really seeing the player, not another monster getting angry or hearing // something // revised behavior so they will wake up if they "see" a player make a noise // but not weapon impact/explosion noises heardit = false; // Paril: revised so that monsters will first try to consider // the current sight client immediately if they can see it. // this fixes them dancing in front of you if you fire every frame. if ((client = AI_GetSightClient(self))) { if (client == self->enemy) { return false; } } // check indirect sources if (!client) { // check monsters that were alerted by players; we can only be alerted if we // can see them if (!(self->spawnflags & SPAWNFLAG_MONSTER_AMBUSH) && (client = AI_GetMonsterAlertedByPlayers(self))) { // KEX_FIXME: when does this happen? // [Paril-KEX] adjusted to clear the client // so we can try other things if (client->enemy == self->enemy || !G_MonsterSourceVisible(self, client)) client = nullptr; } // ROGUE if (client == nullptr) { if (level.disguise_violation_time > level.time) { client = level.disguise_violator; } // ROGUE else if ((client = AI_GetSoundClient(self, true))) { heardit = true; } else if (!(self->enemy) && !(self->spawnflags & SPAWNFLAG_MONSTER_AMBUSH) && (client = AI_GetSoundClient(self, false))) { heardit = true; } } } if (!client) return false; // no clients to get mad at // if the entity went away, forget it if (!client->inuse) return false; if (client == self->enemy) { bool skip_found = true; // [Paril-KEX] slight special behavior if we are currently going to a sound // and we hear a new one; because player noises are re-used, this can leave // us with the "same" enemy even though it's a different noise. if (heardit && (self->monsterinfo.aiflags & AI_SOUND_TARGET)) { vec3_t temp = client->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(temp); if (!FacingIdeal(self)) skip_found = false; else if (!SV_CloseEnough(self, client, 8.f)) skip_found = false; if (!skip_found && (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND)) { self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); } } if (skip_found) return true; // JDC false; } // ROGUE - hintpath coop fix if ((self->monsterinfo.aiflags & AI_HINT_PATH) && coop->integer) heardit = false; // ROGUE if (client->svflags & SVF_MONSTER) { if (!client->enemy) return false; if (client->enemy->flags & FL_NOTARGET) return false; } else if (heardit) { // pgm - a little more paranoia won't hurt.... if ((client->owner) && (client->owner->flags & FL_NOTARGET)) return false; } else if (!client->client) return false; if (!heardit) { // this is where we would check invisibility float r = range_to(self, client); if (r > RANGE_MID) return false; // Paril: revised so that monsters can be woken up // by players 'seen' and attacked at by other monsters // if they are close enough. they don't have to be visible. bool is_visible = ((r <= RANGE_NEAR && client->show_hostile >= level.time && !(self->spawnflags & SPAWNFLAG_MONSTER_AMBUSH)) || (visible(self, client) && (r <= RANGE_MELEE || (self->monsterinfo.aiflags & AI_THIRD_EYE) || infront(self, client)))); if (!is_visible) return false; self->enemy = client; if (strcmp(self->enemy->classname, "player_noise") != 0) { self->monsterinfo.aiflags &= ~AI_SOUND_TARGET; if (!self->enemy->client) { self->enemy = self->enemy->enemy; if (!self->enemy->client) { self->enemy = nullptr; return false; } } } if (self->enemy->client && self->enemy->client->invisible_time > level.time && self->enemy->client->invisibility_fade_time <= level.time) { self->enemy = nullptr; return false; } if (self->monsterinfo.close_sight_tripped) ignore_sight_sound = true; else self->monsterinfo.close_sight_tripped = true; } else // heardit { vec3_t temp; if (self->spawnflags.has(SPAWNFLAG_MONSTER_AMBUSH)) { if (!visible(self, client)) return false; } else { if (!gi.inPHS(self->s.origin, client->s.origin, true)) return false; } temp = client->s.origin - self->s.origin; if (temp.length() > 1000) // too far to hear return false; // check area portals - if they are different and not connected then we can't hear it if (client->areanum != self->areanum) if (!gi.AreasConnected(self->areanum, client->areanum)) return false; self->ideal_yaw = vectoyaw(temp); // ROGUE if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) // ROGUE M_ChangeYaw(self); // hunt the sound for a bit; hopefully find the real player self->monsterinfo.aiflags |= AI_SOUND_TARGET; self->enemy = client; } // // got one // // ROGUE - if we got an enemy, we need to bail out of hint paths, so take over here if (self->monsterinfo.aiflags & AI_HINT_PATH) hintpath_stop(self); // this calls foundtarget for us else FoundTarget(self); // ROGUE if (!(self->monsterinfo.aiflags & AI_SOUND_TARGET) && (self->monsterinfo.sight) && // Paril: adjust to prevent monsters getting stuck in sight loops !ignore_sight_sound) self->monsterinfo.sight(self, self->enemy); return true; } //============================================================================= /* ============ FacingIdeal ============ */ bool FacingIdeal(edict_t *self) { float delta = anglemod(self->s.angles[YAW] - self->ideal_yaw); if (self->monsterinfo.aiflags & AI_PATHING) return !(delta > 5 && delta < 355); return !(delta > 45 && delta < 315); } //============================================================================= // [Paril-KEX] split this out so we can use it for the other bosses bool M_CheckAttack_Base(edict_t *self, float stand_ground_chance, float melee_chance, float near_chance, float mid_chance, float far_chance, float strafe_scalar) { vec3_t spot1, spot2; float chance; trace_t tr; if (self->enemy->flags & FL_NOVISIBLE) return false; if (self->enemy->health > 0) { if (self->enemy->client) { if (self->enemy->client->invisible_time > level.time) { // can't see us at all after this time if (self->enemy->client->invisibility_fade_time <= level.time) return false; } } spot1 = self->s.origin; spot1[2] += self->viewheight; // see if any entities are in the way of the shot if (!self->enemy->client || self->enemy->solid) { spot2 = self->enemy->s.origin; spot2[2] += self->enemy->viewheight; tr = gi.traceline(spot1, spot2, self, MASK_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_SLIME | CONTENTS_LAVA); } else { tr.ent = world; tr.fraction = 0; } // do we have a clear shot? if (!(self->hackflags & HACKFLAG_ATTACK_PLAYER) && tr.ent != self->enemy && !(tr.ent->svflags & SVF_PLAYER)) { // ROGUE - we want them to go ahead and shoot at info_notnulls if they can. if (self->enemy->solid != SOLID_NOT || tr.fraction < 1.0f) // PGM { // PMM - if we can't see our target, and we're not blocked by a monster, go into blind fire if available // Paril - *and* we have at least seen them once if (!(tr.ent->svflags & SVF_MONSTER) && !visible(self, self->enemy) && self->monsterinfo.had_visibility) { if (self->monsterinfo.blindfire && (self->monsterinfo.blind_fire_delay <= 20_sec)) { if (level.time < self->monsterinfo.attack_finished) { // ROGUE return false; } // ROGUE if (level.time < (self->monsterinfo.trail_time + self->monsterinfo.blind_fire_delay)) { // wait for our time return false; } else { // make sure we're not going to shoot a monster tr = gi.traceline(spot1, self->monsterinfo.blind_fire_target, self, CONTENTS_MONSTER); if (tr.allsolid || tr.startsolid || ((tr.fraction < 1.0f) && (tr.ent != self->enemy))) return false; self->monsterinfo.attack_state = AS_BLIND; return true; } } } // pmm return false; } } } // ROGUE float enemy_range = range_to(self, self->enemy); // melee attack if (enemy_range <= RANGE_MELEE) { if (self->monsterinfo.melee && self->monsterinfo.melee_debounce_time <= level.time) self->monsterinfo.attack_state = AS_MELEE; else self->monsterinfo.attack_state = AS_MISSILE; return true; } // if we were in melee just before this but we're too far away, get out of melee state now if (self->monsterinfo.attack_state == AS_MELEE && self->monsterinfo.melee_debounce_time > level.time) self->monsterinfo.attack_state = AS_MISSILE; // missile attack if (!self->monsterinfo.attack) { // ROGUE - fix for melee only monsters & strafing self->monsterinfo.attack_state = AS_STRAIGHT; // ROGUE return false; } if (level.time < self->monsterinfo.attack_finished) return false; if (self->monsterinfo.aiflags & AI_STAND_GROUND) { chance = stand_ground_chance; } else if (enemy_range <= RANGE_MELEE) { chance = melee_chance; } else if (enemy_range <= RANGE_NEAR) { chance = near_chance; } else if (enemy_range <= RANGE_MID) { chance = mid_chance; } else { chance = far_chance; } // PGM - go ahead and shoot every time if it's a info_notnull if ((!self->enemy->client && self->enemy->solid == SOLID_NOT) || (frandom() < chance)) { self->monsterinfo.attack_state = AS_MISSILE; self->monsterinfo.attack_finished = level.time; return true; } // ROGUE -daedalus should strafe more .. this can be done here or in a customized // check_attack code for the hover. if (self->flags & FL_FLY) { if (self->monsterinfo.strafe_check_time <= level.time) { // originally, just 0.3 float strafe_chance; if (!(strcmp(self->classname, "monster_daedalus"))) strafe_chance = 0.8f; else strafe_chance = 0.6f; // if enemy is tesla, never strafe if ((self->enemy) && (self->enemy->classname) && (!strcmp(self->enemy->classname, "tesla_mine"))) strafe_chance = 0; else strafe_chance *= strafe_scalar; if (strafe_chance) { monster_attack_state_t new_state = AS_STRAIGHT; if (frandom() < strafe_chance) new_state = AS_SLIDING; if (new_state != self->monsterinfo.attack_state) { self->monsterinfo.strafe_check_time = level.time + random_time(1_sec, 3_sec); self->monsterinfo.attack_state = new_state; } } } } // do we want the monsters strafing? // [Paril-KEX] no, we don't // [Paril-KEX] if we're pathing, don't immediately reset us to // straight; this allows us to turn to fire and not jerk back and // forth. else if (!(self->monsterinfo.aiflags & AI_PATHING)) self->monsterinfo.attack_state = AS_STRAIGHT; // ROGUE return false; } MONSTERINFO_CHECKATTACK(M_CheckAttack) (edict_t *self) -> bool { return M_CheckAttack_Base(self, 0.7f, 0.4f, 0.25f, 0.06f, 0.f, 1.0f); } /* ============= ai_run_melee Turn and close until within an angle to launch a melee attack ============= */ void ai_run_melee(edict_t *self) { self->ideal_yaw = enemy_yaw; // ROGUE if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) // ROGUE M_ChangeYaw(self); if (FacingIdeal(self)) { self->monsterinfo.melee(self); self->monsterinfo.attack_state = AS_STRAIGHT; } } /* ============= ai_run_missile Turn in place until within an angle to launch a missile attack ============= */ void ai_run_missile(edict_t *self) { self->ideal_yaw = enemy_yaw; // ROGUE if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) // ROGUE M_ChangeYaw(self); if (FacingIdeal(self)) { if (self->monsterinfo.attack) { self->monsterinfo.attack(self); self->monsterinfo.attack_finished = level.time + random_time(1.0_sec, 2.0_sec); } // ROGUE if ((self->monsterinfo.attack_state == AS_MISSILE) || (self->monsterinfo.attack_state == AS_BLIND)) // ROGUE self->monsterinfo.attack_state = AS_STRAIGHT; } }; /* ============= ai_run_slide Strafe sideways, but stay at aproximately the same range ============= */ // ROGUE void ai_run_slide(edict_t *self, float distance) { float ofs; float angle; self->ideal_yaw = enemy_yaw; angle = 90; if (self->monsterinfo.lefty) ofs = angle; else ofs = -angle; if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) M_ChangeYaw(self); // PMM - clamp maximum sideways move for non flyers to make them look less jerky if (!(self->flags & FL_FLY)) distance = min(distance, MAX_SIDESTEP / (gi.frame_time_ms / 10)); if (M_walkmove(self, self->ideal_yaw + ofs, distance)) return; // PMM - if we're dodging, give up on it and go straight if (self->monsterinfo.aiflags & AI_DODGING) { monster_done_dodge(self); // by setting as_straight, caller will know to try straight move self->monsterinfo.attack_state = AS_STRAIGHT; return; } self->monsterinfo.lefty = !self->monsterinfo.lefty; if (M_walkmove(self, self->ideal_yaw - ofs, distance)) return; // PMM - if we're dodging, give up on it and go straight if (self->monsterinfo.aiflags & AI_DODGING) monster_done_dodge(self); // PMM - the move failed, so signal the caller (ai_run) to try going straight self->monsterinfo.attack_state = AS_STRAIGHT; } // ROGUE /* ============= ai_checkattack Decides if we're going to attack or do something else used by ai_run and ai_stand ============= */ bool ai_checkattack(edict_t *self, float dist) { vec3_t temp; bool hesDeadJim; // ROGUE bool retval; // ROGUE if (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND) self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); // this causes monsters to run blindly to the combat point w/o firing if (self->goalentity) { if (self->monsterinfo.aiflags & AI_COMBAT_POINT) { if (self->enemy && range_to(self, self->enemy) > 100.f) return false; } if (self->monsterinfo.aiflags & AI_SOUND_TARGET) { if ((level.time - self->enemy->teleport_time) > 5_sec) { if (self->goalentity == self->enemy) { if (self->movetarget) self->goalentity = self->movetarget; else self->goalentity = nullptr; } self->monsterinfo.aiflags &= ~AI_SOUND_TARGET; } else { self->enemy->show_hostile = level.time + 1_sec; return false; } } } enemy_vis = false; // see if the enemy is dead hesDeadJim = false; if ((!self->enemy) || (!self->enemy->inuse)) { hesDeadJim = true; } else if ( self->monsterinfo.aiflags & AI_FORGET_ENEMY ) { self->monsterinfo.aiflags &= ~AI_FORGET_ENEMY; hesDeadJim = true; } else if (self->monsterinfo.aiflags & AI_MEDIC) { if (!(self->enemy->inuse) || (self->enemy->health > 0)) hesDeadJim = true; } else { if (!(self->monsterinfo.aiflags & AI_BRUTAL)) { if (self->enemy->health <= 0) hesDeadJim = true; } // [Paril-KEX] if our enemy was invisible, lose sight now if (self->enemy->client && self->enemy->client->invisible_time > level.time && self->enemy->client->invisibility_fade_time <= level.time && (self->monsterinfo.aiflags & AI_PURSUE_NEXT)) { hesDeadJim = true; } } if (hesDeadJim && !(self->hackflags & HACKFLAG_ATTACK_PLAYER)) { // ROGUE self->monsterinfo.aiflags &= ~AI_MEDIC; // ROGUE self->enemy = self->goalentity = nullptr; self->monsterinfo.close_sight_tripped = false; // FIXME: look all around for other targets if (self->oldenemy && self->oldenemy->health > 0) { self->enemy = self->oldenemy; self->oldenemy = nullptr; HuntTarget(self); } // ROGUE - multiple teslas make monsters lose track of the player. else if (self->monsterinfo.last_player_enemy && self->monsterinfo.last_player_enemy->health > 0) { self->enemy = self->monsterinfo.last_player_enemy; self->oldenemy = nullptr; self->monsterinfo.last_player_enemy = nullptr; HuntTarget(self); } // ROGUE else { if (self->movetarget && !(self->monsterinfo.aiflags & AI_STAND_GROUND)) { self->goalentity = self->movetarget; self->monsterinfo.walk(self); } else { // we need the pausetime otherwise the stand code // will just revert to walking with no target and // the monsters will wonder around aimlessly trying // to hunt the world entity self->monsterinfo.pausetime = HOLD_FOREVER; self->monsterinfo.stand(self); if (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND) self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); } return true; } } // check knowledge of enemy enemy_vis = visible(self, self->enemy); if (enemy_vis) { self->monsterinfo.had_visibility = true; self->enemy->show_hostile = level.time + 1_sec; // wake up other monsters self->monsterinfo.search_time = level.time + 5_sec; self->monsterinfo.last_sighting = self->monsterinfo.saved_goal = self->enemy->s.origin; // ROGUE if (self->monsterinfo.aiflags & AI_LOST_SIGHT) { self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; if (self->monsterinfo.move_block_change_time < level.time) self->monsterinfo.aiflags &= ~AI_TEMP_MELEE_COMBAT; } self->monsterinfo.trail_time = level.time; self->monsterinfo.blind_fire_target = self->monsterinfo.last_sighting + (self->enemy->velocity * -0.1f); self->monsterinfo.blind_fire_delay = 0_ms; // ROGUE } enemy_infront = infront(self, self->enemy); temp = self->enemy->s.origin - self->s.origin; enemy_yaw = vectoyaw(temp); // PMM -- reordered so the monster specific checkattack is called before the run_missle/melee/checkvis // stuff .. this allows for, among other things, circle strafing and attacking while in ai_run retval = false; if (self->monsterinfo.checkattack_time <= level.time) { self->monsterinfo.checkattack_time = level.time + 0.1_sec; retval = self->monsterinfo.checkattack(self); } if (retval || self->monsterinfo.attack_state >= AS_MISSILE) { // PMM if (self->monsterinfo.attack_state == AS_MISSILE) { ai_run_missile(self); return true; } if (self->monsterinfo.attack_state == AS_MELEE) { ai_run_melee(self); return true; } // PMM -- added so monsters can shoot blind if (self->monsterinfo.attack_state == AS_BLIND) { ai_run_missile(self); return true; } // pmm // if enemy is not currently visible, we will never attack if (!enemy_vis) return false; // PMM } return retval; // PMM } /* ============= ai_run The monster has an enemy it is trying to kill ============= */ void ai_run(edict_t *self, float dist) { vec3_t v; edict_t *tempgoal; edict_t *save; bool newEnemy; edict_t *marker; float d1, d2; trace_t tr; vec3_t v_forward, v_right; float left, center, right; vec3_t left_target, right_target; // ROGUE bool retval; bool alreadyMoved = false; bool gotcha = false; edict_t *realEnemy; // ROGUE // if we're going to a combat point, just proceed if (self->monsterinfo.aiflags & AI_COMBAT_POINT) { ai_checkattack(self, dist); M_MoveToGoal(self, dist); if (self->movetarget) { // nb: this is done from the centroid and not viewheight on purpose; trace_t tr = gi.trace((self->absmax + self->absmin) * 0.5f, { -2.f, -2.f, -2.f }, { 2.f, 2.f, 2.f }, self->movetarget->s.origin, self, CONTENTS_SOLID); // [Paril-KEX] special case: if we're stand ground & knocked way too far away // from our path_corner, or we can't see it any more, assume all // is lost. if ((self->monsterinfo.aiflags & AI_REACHED_HOLD_COMBAT) && (((closest_point_to_box(self->movetarget->s.origin, self->absmin, self->absmax) - self->movetarget->s.origin).length() > 160.f) || (tr.fraction < 1.0f && tr.plane.normal.z <= 0.7f))) // if we hit a climbable, ignore this result { self->monsterinfo.aiflags &= ~AI_COMBAT_POINT; self->movetarget = nullptr; self->target = nullptr; self->goalentity = self->enemy; } else return; } else return; } // PMM if ((self->monsterinfo.aiflags & AI_DUCKED) && self->monsterinfo.unduck) self->monsterinfo.unduck(self); //========== // PGM // if we're currently looking for a hint path if (self->monsterinfo.aiflags & AI_HINT_PATH) { // determine direction to our destination hintpath. M_MoveToGoal(self, dist); if (!self->inuse) return; // first off, make sure we're looking for the player, not a noise he made if (self->enemy) { if (self->enemy->inuse) { if (strcmp(self->enemy->classname, "player_noise") != 0) realEnemy = self->enemy; else if (self->enemy->owner) realEnemy = self->enemy->owner; else // uh oh, can't figure out enemy, bail { self->enemy = nullptr; hintpath_stop(self); return; } } else { self->enemy = nullptr; hintpath_stop(self); return; } } else { hintpath_stop(self); return; } if (coop->integer) { // if we're in coop, check my real enemy first .. if I SEE him, set gotcha to true if (self->enemy && visible(self, realEnemy)) gotcha = true; else // otherwise, let FindTarget bump us out of hint paths, if appropriate FindTarget(self); } else { if (self->enemy && visible(self, realEnemy)) gotcha = true; } // if we see the player, stop following hintpaths. if (gotcha) // disconnect from hintpaths and start looking normally for players. hintpath_stop(self); return; } // PGM //========== if (self->monsterinfo.aiflags & AI_SOUND_TARGET) { // PMM - paranoia checking if (self->enemy) v = self->s.origin - self->enemy->s.origin; bool touching_noise = SV_CloseEnough(self, self->enemy, dist * (gi.tick_rate / 10)); if ((!self->enemy) || (touching_noise && FacingIdeal(self))) // pmm { self->monsterinfo.aiflags |= (AI_STAND_GROUND | AI_TEMP_STAND_GROUND); self->s.angles[YAW] = self->ideal_yaw; self->monsterinfo.stand(self); self->monsterinfo.close_sight_tripped = false; return; } // if we're close to the goal, just turn if (touching_noise) M_ChangeYaw(self); else M_MoveToGoal(self, dist); // ROGUE - prevent double moves for sound_targets alreadyMoved = true; if (!self->inuse) return; // PGM - g_touchtrigger free problem // ROGUE if (!FindTarget(self)) return; } // PMM -- moved ai_checkattack up here so the monsters can attack while strafing or charging // PMM -- if we're dodging, make sure to keep the attack_state AS_SLIDING retval = ai_checkattack(self, dist); // PMM - don't strafe if we can't see our enemy if ((!enemy_vis) && (self->monsterinfo.attack_state == AS_SLIDING)) self->monsterinfo.attack_state = AS_STRAIGHT; // unless we're dodging (dodging out of view looks smart) if (self->monsterinfo.aiflags & AI_DODGING) self->monsterinfo.attack_state = AS_SLIDING; // pmm if (self->monsterinfo.attack_state == AS_SLIDING) { // PMM - protect against double moves if (!alreadyMoved) ai_run_slide(self, dist); // PMM // we're using attack_state as the return value out of ai_run_slide to indicate whether or not the // move succeeded. If the move succeeded, and we're still sliding, we're done in here (since we've // had our chance to shoot in ai_checkattack, and have moved). // if the move failed, our state is as_straight, and it will be taken care of below if ((!retval) && (self->monsterinfo.attack_state == AS_SLIDING)) return; } else if (self->monsterinfo.aiflags & AI_CHARGING) { self->ideal_yaw = enemy_yaw; if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING)) M_ChangeYaw(self); } if (retval) { // PMM - is this useful? Monsters attacking usually call the ai_charge routine.. // the only monster this affects should be the soldier if ((dist || (self->monsterinfo.aiflags & AI_ALTERNATE_FLY)) && (!alreadyMoved) && (self->monsterinfo.attack_state == AS_STRAIGHT) && (!(self->monsterinfo.aiflags & AI_STAND_GROUND))) { M_MoveToGoal(self, dist); } if ((self->enemy) && (self->enemy->inuse) && (enemy_vis)) { if (self->monsterinfo.aiflags & AI_LOST_SIGHT) { self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; if (self->monsterinfo.move_block_change_time < level.time) self->monsterinfo.aiflags &= ~AI_TEMP_MELEE_COMBAT; } self->monsterinfo.last_sighting = self->monsterinfo.saved_goal = self->enemy->s.origin; self->monsterinfo.trail_time = level.time; // PMM self->monsterinfo.blind_fire_target = self->monsterinfo.last_sighting + (self->enemy->velocity * -0.1f); self->monsterinfo.blind_fire_delay = 0_ms; // pmm } return; } // PMM // PGM - added a little paranoia checking here... 9/22/98 if ((self->enemy) && (self->enemy->inuse) && (enemy_vis)) { // PMM - check for alreadyMoved if (!alreadyMoved) M_MoveToGoal(self, dist); if (!self->inuse) return; // PGM - g_touchtrigger free problem if (self->monsterinfo.aiflags & AI_LOST_SIGHT) { self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; if (self->monsterinfo.move_block_change_time < level.time) self->monsterinfo.aiflags &= ~AI_TEMP_MELEE_COMBAT; } self->monsterinfo.last_sighting = self->monsterinfo.saved_goal = self->enemy->s.origin; self->monsterinfo.trail_time = level.time; // PMM self->monsterinfo.blind_fire_target = self->monsterinfo.last_sighting + (self->enemy->velocity * -0.1f); self->monsterinfo.blind_fire_delay = 0_ms; // pmm // [Paril-KEX] if our enemy is literally right next to us, give // us more rotational speed so we don't get circled if (range_to(self, self->enemy) <= RANGE_MELEE * 2.5f) M_ChangeYaw(self); return; } //======= // PGM // if we've been looking (unsuccessfully) for the player for 10 seconds // PMM - reduced to 5, makes them much nastier if ((self->monsterinfo.trail_time + 5_sec) <= level.time) { // and we haven't checked for valid hint paths in the last 10 seconds if ((self->monsterinfo.last_hint_time + 10_sec) <= level.time) { // check for hint_paths. self->monsterinfo.last_hint_time = level.time; if (monsterlost_checkhint(self)) return; } } // PGM //======= // PMM - moved down here to allow monsters to get on hint paths // coop will change to another enemy if visible if (coop->integer) FindTarget(self); // pmm if ((self->monsterinfo.search_time) && (level.time > (self->monsterinfo.search_time + 20_sec))) { // PMM - double move protection if (!alreadyMoved) M_MoveToGoal(self, dist); self->monsterinfo.search_time = 0_ms; return; } save = self->goalentity; tempgoal = G_Spawn(); self->goalentity = tempgoal; newEnemy = false; if (!(self->monsterinfo.aiflags & AI_LOST_SIGHT)) { // just lost sight of the player, decide where to go first self->monsterinfo.aiflags |= (AI_LOST_SIGHT | AI_PURSUIT_LAST_SEEN); self->monsterinfo.aiflags &= ~(AI_PURSUE_NEXT | AI_PURSUE_TEMP); newEnemy = true; // immediately try paths self->monsterinfo.path_blocked_counter = 0_ms; self->monsterinfo.path_wait_time = 0_ms; } if (self->monsterinfo.aiflags & AI_PURSUE_NEXT) { self->monsterinfo.aiflags &= ~AI_PURSUE_NEXT; // give ourself more time since we got this far self->monsterinfo.search_time = level.time + 5_sec; if (self->monsterinfo.aiflags & AI_PURSUE_TEMP) { self->monsterinfo.aiflags &= ~AI_PURSUE_TEMP; marker = nullptr; self->monsterinfo.last_sighting = self->monsterinfo.saved_goal; newEnemy = true; } else if (self->monsterinfo.aiflags & AI_PURSUIT_LAST_SEEN) { self->monsterinfo.aiflags &= ~AI_PURSUIT_LAST_SEEN; marker = PlayerTrail_Pick(self, false); } else { marker = PlayerTrail_Pick(self, true); } if (marker) { self->monsterinfo.last_sighting = marker->s.origin; self->monsterinfo.trail_time = marker->timestamp; self->s.angles[YAW] = self->ideal_yaw = marker->s.angles[YAW]; newEnemy = true; } } if (!(self->monsterinfo.aiflags & AI_PATHING) && boxes_intersect(self->monsterinfo.last_sighting, self->monsterinfo.last_sighting, self->s.origin + self->mins, self->s.origin + self->maxs)) { self->monsterinfo.aiflags |= AI_PURSUE_NEXT; dist = min(dist, (self->s.origin - self->monsterinfo.last_sighting).length()); // [Paril-KEX] this helps them navigate corners when two next pursuits // are really close together self->monsterinfo.random_change_time = level.time + 10_hz; } self->goalentity->s.origin = self->monsterinfo.last_sighting; if (newEnemy) { tr = gi.trace(self->s.origin, self->mins, self->maxs, self->monsterinfo.last_sighting, self, MASK_PLAYERSOLID); if (tr.fraction < 1) { v = self->goalentity->s.origin - self->s.origin; d1 = v.length(); center = tr.fraction; d2 = d1 * ((center + 1) / 2); float backup_yaw = self->s.angles.y; self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v); AngleVectors(self->s.angles, v_forward, v_right, nullptr); v = { d2, -16, 0 }; left_target = G_ProjectSource(self->s.origin, v, v_forward, v_right); tr = gi.trace(self->s.origin, self->mins, self->maxs, left_target, self, MASK_PLAYERSOLID); left = tr.fraction; v = { d2, 16, 0 }; right_target = G_ProjectSource(self->s.origin, v, v_forward, v_right); tr = gi.trace(self->s.origin, self->mins, self->maxs, right_target, self, MASK_PLAYERSOLID); right = tr.fraction; center = (d1 * center) / d2; if (left >= center && left > right) { if (left < 1) { v = { d2 * left * 0.5f, -16, 0 }; left_target = G_ProjectSource(self->s.origin, v, v_forward, v_right); } self->monsterinfo.saved_goal = self->monsterinfo.last_sighting; self->monsterinfo.aiflags |= AI_PURSUE_TEMP; self->goalentity->s.origin = left_target; self->monsterinfo.last_sighting = left_target; v = self->goalentity->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(v); } else if (right >= center && right > left) { if (right < 1) { v = { d2 * right * 0.5f, 16, 0 }; right_target = G_ProjectSource(self->s.origin, v, v_forward, v_right); } self->monsterinfo.saved_goal = self->monsterinfo.last_sighting; self->monsterinfo.aiflags |= AI_PURSUE_TEMP; self->goalentity->s.origin = right_target; self->monsterinfo.last_sighting = right_target; v = self->goalentity->s.origin - self->s.origin; self->ideal_yaw = vectoyaw(v); } self->s.angles[YAW] = backup_yaw; } } M_MoveToGoal(self, dist); G_FreeEdict(tempgoal); if (!self->inuse) return; // PGM - g_touchtrigger free problem if (self) self->goalentity = save; }