An interactive breakdown of the do { … } while loop you wrote: a nearest-target search that drives a server-plugin lock-on for single-player Source games. Watch every line run, drag the NPCs around, and see how the state changes.
Top-down arena: the amber triangle is the player. Every tick advances the loop by one step; the highlighted lines on the right are the ones executing.
The loop is a classic linear minimum search over the server's entity list, with the "apply" step folded into the start of each pass.
FirstEntity() returns the first server entity (normally worldspawn). NextEntity() walks forward until it returns nullptr.
When the cursor is back at the first entity, the winner of the previous pass is used to set eye angles, then the best distance is reset to FLT_MAX.
Point entities without a model are ignored. The classname from GetEntityName() is checked against the enemy list (npc_combine_s, npc_zombie…).
Distance from the player's eye to the enemy's eye. If it beats the best so far, both the distance and the vector are stored for the next commit.
It works, but a few details cost cycles or produce odd behaviour at the edges.
SetPlayerEyeAnglesToPosition runs at the top of the pass with the result of the pass before. The very first frame aims at GetFurthestVector(), and a target that just died stays aimed at for one more frame. Aim after the loop instead.
GetPlayerPosition() can't change during the loop, but it's called once for every enemy found. With 40 NPCs that's 40 redundant calls per frame. Hoist it above the loop.
FirstEntity() on every iterationThe "new pass" test calls FirstEntity() again for each entity just to compare pointers. Cache it, or better, do the reset before the loop and drop the check.
std::string per entityA string is built for every entity with a model. Short classnames fit in the small-string buffer, but longer ones like npc_antlionguard allocate. Have IsEntityEnemy take a std::string_view.
<= picks the last tieWith equal distances, the later entity wins. With floats that rarely happens, but < keeps the first match and stops needless writes.
If nothing matches, closestEnemyVector stays at GetFurthestVector() and the view snaps there every frame. Only aim when a target was actually found (std::optional).
No line-of-sight trace, health check or field-of-view limit, so it will lock through walls and onto dying NPCs. Add a UTIL_TraceLine visibility test and a GetHealth() > 0 filter before comparing.
// Call once per GameFrame
void UpdateAim() {
Vector eyePosition{};
QAngle eyeAngles{};
GetServerTools()->GetPlayerPosition(eyePosition, eyeAngles);
float bestDistance{ std::numeric_limits<float>::max() };
std::optional<Vector> bestTarget{};
for (auto* entity{ reinterpret_cast<IServerEntity*>(GetServerTools()->FirstEntity()) };
entity != nullptr;
entity = reinterpret_cast<IServerEntity*>(GetServerTools()->NextEntity(entity))) {
if (entity->GetModelName().ToCStr() == nullptr) continue;
if (!IsEntityEnemy(GetEntityName(entity))) continue; // takes std::string_view
const auto enemyEyePosition{ GetEyePosition(entity) };
const auto distance{ VectorDistance(enemyEyePosition, eyePosition) };
if (distance < bestDistance) {
bestDistance = distance;
bestTarget = enemyEyePosition;
}
}
if (bestTarget) {
SetPlayerEyeAnglesToPosition(*bestTarget); // same frame, no lag
}
}