refactor: re-write AOE, add FilterTargets, Update TacArc Reading

dGame/dBehaviors/AreaOfEffectBehavior.cpp

@@ -21,133 +21,106 @@ void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream* b
 	}
 
 	if (targetCount > this->m_maxTargets) {
+		Game::logger->Log("AreaOfEffectBehavior::Handle", "More targets than allowed! Likely a cheating attempt. Got: %i, Max: %i", targetCount, this->m_maxTargets);
 		return;
 	}
 
 	std::vector<LWOOBJID> targets;
-
 	targets.reserve(targetCount);
 
 	for (auto i = 0u; i < targetCount; ++i) {
 		LWOOBJID target{};
-
 		if (!bitStream->Read(target)) {
 			Game::logger->Log("AreaOfEffectBehavior", "failed to read in target %i from bitStream, aborting target Handle!", i);
 			return;
 		};
-
 		targets.push_back(target);
 	}
 
 	for (auto target : targets) {
 		branch.target = target;
-
 		this->m_action->Handle(context, bitStream, branch);
 	}
 }
 
 void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
-	auto* self = EntityManager::Instance()->GetEntity(context->caster);
-	if (self == nullptr) {
-		Game::logger->Log("AreaOfEffectBehavior", "Invalid self for (%llu)!", context->originator);
-
+	auto* caster = EntityManager::Instance()->GetEntity(context->caster);
+	if (!caster) {
+		Game::logger->Log("AreaOfEffectBehavior::Calculate", "There is no caster to be found!");
 		return;
 	}
 
-	auto reference = branch.isProjectile ? branch.referencePosition : self->GetPosition();
-
-	std::vector<Entity*> targets;
-
-	auto* presetTarget = EntityManager::Instance()->GetEntity(branch.target);
-
-	if (presetTarget != nullptr) {
-		if (this->m_radius * this->m_radius >= Vector3::DistanceSquared(reference, presetTarget->GetPosition())) {
-			targets.push_back(presetTarget);
-		}
+	// determine the position we are casting the AOE from
+	auto reference = branch.isProjectile ? branch.referencePosition : caster->GetPosition();
+	if (m_UseTargetPosition && branch.target) {
+		auto branchTarget = EntityManager::Instance()->GetEntity(branch.target);
+		reference = branchTarget->GetPosition();
 	}
 
-	int32_t includeFaction = m_includeFaction;
-
-	if (self->GetLOT() == 14466) // TODO: Fix edge case
-	{
-		includeFaction = 1;
-	}
-
-	// Gets all of the valid targets, passing in if should target enemies and friends
-	for (auto validTarget : context->GetValidTargets(m_ignoreFaction, includeFaction, m_TargetSelf == 1, m_targetEnemy == 1, m_targetFriend == 1)) {
-		auto* entity = EntityManager::Instance()->GetEntity(validTarget);
-
-		if (entity == nullptr) {
-			Game::logger->Log("AreaOfEffectBehavior", "Invalid target (%llu) for (%llu)!", validTarget, context->originator);
-
-			continue;
-		}
-
-		if (std::find(targets.begin(), targets.end(), entity) != targets.end()) {
-			continue;
-		}
-
-		auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
-
-		if (destroyableComponent == nullptr) {
-			continue;
-		}
+	reference += this->m_offset;
 
-		if (destroyableComponent->HasFaction(m_ignoreFaction)) {
-			continue;
-		}
+	std::vector<Entity*> allTargets {};
+	std::vector<Entity*> validTargets {};
+	// Gets all of the valid validTargets, passing in if should target enemies and friends
+	allTargets = context->FilterTargets(this->m_ignoreFactionList, this->m_includeFactionList, this->m_targetSelf, this->m_targetEnemy, this->m_targetFriend, this->m_targetTeam);
 
-		const auto distance = Vector3::DistanceSquared(reference, entity->GetPosition());
+	// filter based on the radius
+	for (auto* candidate : allTargets) if (NiPoint3::Distance(reference, candidate->GetPosition()) <= this->m_radius) validTargets.push_back(candidate);
 
-		if (this->m_radius * this->m_radius >= distance && (this->m_maxTargets == 0 || targets.size() < this->m_maxTargets)) {
-			targets.push_back(entity);
+	// sort by distance
+	std::sort(validTargets.begin(), validTargets.end(), [reference](Entity* a, Entity* b) {
+		const auto aDistance = NiPoint3::Distance(a->GetPosition(), reference);
+		const auto bDistance = NiPoint3::Distance(b->GetPosition(), reference);
+		return aDistance < bDistance;
 		}
-	}
-
-	std::sort(targets.begin(), targets.end(), [reference](Entity* a, Entity* b) {
-		const auto aDistance = Vector3::DistanceSquared(a->GetPosition(), reference);
-		const auto bDistance = Vector3::DistanceSquared(b->GetPosition(), reference);
-
-		return aDistance > bDistance;
-		});
+	);
 
-	const uint32_t size = targets.size();
+	// resize if we have more than max validTargets allows
+	if (validTargets.size() > this->m_maxTargets) validTargets.resize(this->m_maxTargets);
 
-	bitStream->Write(size);
+	bitStream->Write<uint32_t>(validTargets.size());
 
-	if (size == 0) {
-		return;
-	}
-
-	context->foundTarget = true;
+	if (validTargets.size() > 0) context->foundTarget = true;
 
-	for (auto* target : targets) {
-		bitStream->Write(target->GetObjectID());
-
-		PlayFx(u"cast", context->originator, target->GetObjectID());
+	// write all the targets to the bitstream
+	for (auto* validTarget : validTargets) {
+		bitStream->Write(validTarget->GetObjectID());
 	}
 
-	for (auto* target : targets) {
-		branch.target = target->GetObjectID();
-
+	// then case all the actions
+	for (auto* validTarget : validTargets) {
+		bitStream->Write(validTarget->GetObjectID());
+		branch.target = validTarget->GetObjectID();
 		this->m_action->Calculate(context, bitStream, branch);
 	}
+
+	PlayFx(u"cast", context->originator);
 }
 
 void AreaOfEffectBehavior::Load() {
-	this->m_action = GetAction("action");
 
+	this->m_action = GetAction("action");
 	this->m_radius = GetFloat("radius");
+	this->m_maxTargets = GetInt("max targets", 100);
+	if (this->m_maxTargets == 0) this->m_maxTargets = 100;
+	this->m_offset = NiPoint3(
+		GetFloat("offset_x", 0.0f),
+		GetFloat("offset_y", 0.0f),
+		GetFloat("offset_z", 0.0f)
+	);
+	// params after this are needed for filter targets
+	const auto parameters = GetParameterNames();
+	for (const auto& parameter : parameters) {
+		if (parameter.first.rfind("include_faction", 0) == 0) {
+			this->m_includeFactionList.push_front(parameter.second);
+		} else if (parameter.first.rfind("ignore_faction", 0) == 0) {
+			this->m_ignoreFactionList.push_front(parameter.second);
+		}
+	}
+	this->m_targetSelf = GetBoolean("target_self", false);
+	this->m_targetEnemy = GetBoolean("target_enemy", false);
+	this->m_targetFriend = GetBoolean("target_friend", false);
+	this->m_targetTeam = GetBoolean("target_team", false);
 
-	this->m_maxTargets = GetInt("max targets");
-
-	this->m_ignoreFaction = GetInt("ignore_faction");
-
-	this->m_includeFaction = GetInt("include_faction");
-
-	this->m_TargetSelf = GetInt("target_self");
-
-	this->m_targetEnemy = GetInt("target_enemy");
 
-	this->m_targetFriend = GetInt("target_friend");
 }

dGame/dBehaviors/AreaOfEffectBehavior.h

@@ -1,30 +1,25 @@
 #pragma once
 #include "Behavior.h"
+#include <forward_list>
 
 class AreaOfEffectBehavior final : public Behavior
 {
 public:
 	Behavior* m_action;
-
 	uint32_t m_maxTargets;
-
 	float m_radius;
-
-	int32_t m_ignoreFaction;
-
-	int32_t m_includeFaction;
-
-	int32_t m_TargetSelf;
-
-	int32_t m_targetEnemy;
-
-	int32_t m_targetFriend;
-
-	/*
-	 * Inherited
-	 */
-	explicit AreaOfEffectBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
-	}
+	bool m_UseTargetPosition;
+	bool m_UseTargetAsCaster;
+	NiPoint3 m_offset;
+
+	std::forward_list<int32_t> m_ignoreFactionList {};
+	std::forward_list<int32_t> m_includeFactionList {};
+	bool m_targetSelf;
+	bool m_targetEnemy;
+	bool m_targetFriend;
+	bool m_targetTeam;
+
+	explicit AreaOfEffectBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {}
 
 	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 

dGame/dBehaviors/BehaviorContext.cpp

@@ -16,6 +16,7 @@
 #include "PhantomPhysicsComponent.h"
 #include "RebuildComponent.h"
 #include "eReplicaComponentType.h"
+#include "TeamManager.h"
 
 BehaviorSyncEntry::BehaviorSyncEntry() {
 }
@@ -289,46 +290,74 @@ void BehaviorContext::Reset() {
 	this->scheduledUpdates.clear();
 }
 
-std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, int32_t includeFaction, bool targetSelf, bool targetEnemy, bool targetFriend) const {
-	auto* entity = EntityManager::Instance()->GetEntity(this->caster);
+std::vector<Entity*> BehaviorContext::FilterTargets(std::forward_list<int32_t> ignoreFactionList, std::forward_list<int32_t> includeFactionList, bool targetSelf, bool targetEnemy, bool targetFriend, bool targetTeam) const {
+	std::vector<Entity*> targets = {};
 
-	std::vector<LWOOBJID> targets;
+	// if we aren't targeting anything, then return empty targets list
+	if (!targetSelf && !targetEnemy && !targetFriend && !targetTeam && ignoreFactionList.empty() && includeFactionList.empty()) return targets;
 
-	if (entity == nullptr) {
-		Game::logger->Log("BehaviorContext", "Invalid entity for (%llu)!", this->originator);
+	auto* caster = EntityManager::Instance()->GetEntity(this->caster);
 
+	// if the caster is not there, return empty targets list
+	if (!caster) {
+		Game::logger->LogDebug("BehaviorContext", "Invalid caster for (%llu)!", this->originator);
 		return targets;
 	}
 
-	if (!ignoreFaction && !includeFaction) {
-		for (auto entry : entity->GetTargetsInPhantom()) {
-			auto* instance = EntityManager::Instance()->GetEntity(entry);
-
-			if (instance == nullptr) {
-				continue;
+	auto* casterDestroyableComponent = caster->GetComponent<DestroyableComponent>();
+	if (!casterDestroyableComponent) return targets;
+
+	auto candidates = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::DESTROYABLE);
+	for (auto* candidate : candidates) {
+		if (!candidate) continue;
+		if (candidate == caster){
+			if (targetSelf) targets.push_back(candidate);
+		} else {
+			if (CheckTargetingRequirements(candidate)){
+				auto candidateDestroyableComponent = candidate->GetComponent<DestroyableComponent>();
+				if (!candidateDestroyableComponent) continue;
+				if (candidateDestroyableComponent->GetIsDead()) continue;
+				auto candidateFactions = candidateDestroyableComponent->GetFactionIDs();
+				if (!CheckFactionList(includeFactionList, candidateFactions)){
+					if (targetTeam){
+						auto* team = TeamManager::Instance()->GetTeam(this->caster);
+						if (team){
+							if(std::find(team->members.begin(), team->members.end(), candidate->GetObjectID()) != team->members.end()){
+								targets.push_back(candidate);
+								continue;
+							}
+						}
+					}
+					auto isEnemy = casterDestroyableComponent->IsEnemy(candidate);
+					if (!targetFriend && !isEnemy) continue;
+					else if(!targetEnemy && isEnemy) continue;
+					else if(!CheckFactionList(ignoreFactionList, candidateFactions)) targets.push_back(candidate);
+				} else targets.push_back(candidate);
 			}
-
-			targets.push_back(entry);
 		}
 	}
+	return targets;
+}
 
-	if (ignoreFaction || includeFaction || (!entity->HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) && targets.empty())) {
-		DestroyableComponent* destroyableComponent;
-		if (!entity->TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
-			return targets;
-		}
+// some basic checks as well as the check that matters for this: if the quickbuild is complete
+bool BehaviorContext::CheckTargetingRequirements(const Entity* target) const {
+	// if the target is a nullptr, then it's not valid
+	if (!target) return false;
 
-		auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS);
-		for (auto* candidate : entities) {
-			const auto id = candidate->GetObjectID();
+	// only target quickbuilds in the are completed
+	auto* targetQuickbuild = target->GetComponent<RebuildComponent>();
+	if (targetQuickbuild && targetQuickbuild->GetState() != REBUILD_COMPLETED) return false;
 
-			if ((id != entity->GetObjectID() || targetSelf) && destroyableComponent->CheckValidity(id, ignoreFaction || includeFaction, targetEnemy, targetFriend)) {
-				targets.push_back(id);
-			}
-		}
-	}
+	return true;
+}
 
-	return targets;
+// returns true if any of the object factions are in the faction list
+bool BehaviorContext::CheckFactionList(std::forward_list<int32_t> factionList, std::vector<int32_t> objectsFactions) const {
+	if (factionList.empty() || objectsFactions.empty()) return false;
+	for (auto faction : factionList){
+		if(std::find(objectsFactions.begin(), objectsFactions.end(), faction) != objectsFactions.end()) return true;
+	}
+	return false;
 }
 
 

dGame/dBehaviors/BehaviorContext.h

@@ -6,6 +6,7 @@
 #include "GameMessages.h"
 
 #include <vector>
+#include <forward_list>
 
 class Behavior;
 
@@ -104,7 +105,11 @@ struct BehaviorContext
 
 	void Reset();
 
-	std::vector<LWOOBJID> GetValidTargets(int32_t ignoreFaction = 0, int32_t includeFaction = 0, const bool targetSelf = false, const bool targetEnemy = true, const bool targetFriend = false) const;
+	std::vector<Entity*> FilterTargets(std::forward_list<int32_t> ignoreFaction = {}, std::forward_list<int32_t> includeFaction = {}, const bool targetSelf = false, const bool targetEnemy = true, const bool targetFriend = false, const bool targetTeam = false) const;
+
+	bool CheckTargetingRequirements(const Entity* target) const;
+
+	bool CheckFactionList(std::forward_list<int32_t> factionList, std::vector<int32_t> objectsFactions) const;
 
 	explicit BehaviorContext(LWOOBJID originator, bool calculation = false);