DarkflameServer/dGame/dComponents/SkillComponent.cpp
jadebenn ef6f2f133e
chore: Eradicate C-style casts and further clean up some code (#1361)
* cast and code cleanup

* cast cleanup

* bug fixes and improvements

* no getBoolField method exists

* fixes

* unbroke sg cannon scoring

* removing comments

* Remove the c-style cast warning I added from CMakeLists now that they're gone (it triggers on 3rd party dependencies and slows down compilation)

* (Hopefully) fix MacOS compilation error

* partially-implemented feedback

* more updates to account for feedback

* change bool default

---------

Co-authored-by: jadebenn <jonahebenn@yahoo.com>
2023-12-27 22:18:20 -06:00

499 lines
13 KiB
C++

/*
* Darkflame Universe
* Copyright 2018
*/
#include "SkillComponent.h"
#include <sstream>
#include <vector>
#include "BehaviorContext.h"
#include "BehaviorBranchContext.h"
#include "Behavior.h"
#include "CDClientDatabase.h"
#include "dServer.h"
#include "EntityManager.h"
#include "Game.h"
#include "BitStreamUtils.h"
#include "BaseCombatAIComponent.h"
#include "ScriptComponent.h"
#include "BuffComponent.h"
#include "EchoStartSkill.h"
#include "DoClientProjectileImpact.h"
#include "CDClientManager.h"
#include "CDSkillBehaviorTable.h"
#include "eConnectionType.h"
#include "eClientMessageType.h"
ProjectileSyncEntry::ProjectileSyncEntry() {
}
std::unordered_map<uint32_t, uint32_t> SkillComponent::m_skillBehaviorCache = {};
bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t skillUid, RakNet::BitStream* bitStream, const LWOOBJID target, uint32_t skillID) {
auto* context = new BehaviorContext(this->m_Parent->GetObjectID());
context->caster = m_Parent->GetObjectID();
context->skillID = skillID;
this->m_managedBehaviors.insert_or_assign(skillUid, context);
auto* behavior = Behavior::CreateBehavior(behaviorId);
const auto branch = BehaviorBranchContext(target, 0);
behavior->Handle(context, bitStream, branch);
context->ExecuteUpdates();
return !context->failed;
}
void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syncId, RakNet::BitStream* bitStream) {
const auto index = this->m_managedBehaviors.find(skillUid);
if (index == this->m_managedBehaviors.end()) {
LOG("Failed to find skill with uid (%i)!", skillUid, syncId);
return;
}
auto* context = index->second;
context->SyncBehavior(syncId, bitStream);
}
void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::BitStream* bitStream, const LWOOBJID target) {
auto index = -1;
for (auto i = 0u; i < this->m_managedProjectiles.size(); ++i) {
const auto& projectile = this->m_managedProjectiles.at(i);
if (projectile.id == projectileId) {
index = i;
break;
}
}
if (index == -1) {
LOG("Failed to find projectile id (%llu)!", projectileId);
return;
}
const auto sync_entry = this->m_managedProjectiles.at(index);
auto query = CDClientDatabase::CreatePreppedStmt(
"SELECT behaviorID FROM SkillBehavior WHERE skillID = (SELECT skillID FROM ObjectSkills WHERE objectTemplate = ?);");
query.bind(1, static_cast<int>(sync_entry.lot));
auto result = query.execQuery();
if (result.eof()) {
LOG("Failed to find skill id for (%i)!", sync_entry.lot);
return;
}
const auto behavior_id = static_cast<uint32_t>(result.getIntField(0));
result.finalize();
auto* behavior = Behavior::CreateBehavior(behavior_id);
auto branch = sync_entry.branchContext;
branch.isProjectile = true;
if (target != LWOOBJID_EMPTY) {
branch.target = target;
}
behavior->Handle(sync_entry.context, bitStream, branch);
this->m_managedProjectiles.erase(this->m_managedProjectiles.begin() + index);
}
void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, BehaviorContext* context, const BehaviorBranchContext& branch, const LOT lot) {
ProjectileSyncEntry entry;
entry.context = context;
entry.branchContext = branch;
entry.lot = lot;
entry.id = projectileId;
this->m_managedProjectiles.push_back(entry);
}
void SkillComponent::Update(const float deltaTime) {
if (!m_Parent->HasComponent(eReplicaComponentType::BASE_COMBAT_AI) && m_Parent->GetLOT() != 1) {
CalculateUpdate(deltaTime);
}
if (m_Parent->IsPlayer()) {
for (const auto& pair : this->m_managedBehaviors) pair.second->UpdatePlayerSyncs(deltaTime);
}
std::map<uint32_t, BehaviorContext*> keep{};
for (const auto& pair : this->m_managedBehaviors) {
auto* context = pair.second;
if (context == nullptr) {
continue;
}
if (context->clientInitalized) {
context->CalculateUpdate(deltaTime);
} else {
context->Update(deltaTime);
}
// Cleanup old behaviors
if (context->syncEntries.empty() && context->timerEntries.empty()) {
auto any = false;
for (const auto& projectile : this->m_managedProjectiles) {
if (projectile.context == context) {
any = true;
break;
}
}
if (!any) {
context->Reset();
delete context;
context = nullptr;
continue;
}
}
keep.insert_or_assign(pair.first, context);
}
this->m_managedBehaviors = keep;
}
void SkillComponent::Reset() {
for (const auto& behavior : this->m_managedBehaviors) {
delete behavior.second;
}
this->m_managedProjectiles.clear();
this->m_managedBehaviors.clear();
}
void SkillComponent::Interrupt() {
// TODO: need to check immunities on the destroyable component, but they aren't implemented
auto* combat = m_Parent->GetComponent<BaseCombatAIComponent>();
if (combat != nullptr && combat->GetStunImmune()) return;
for (const auto& behavior : this->m_managedBehaviors) {
for (const auto& behaviorEndEntry : behavior.second->endEntries) {
behaviorEndEntry.behavior->End(behavior.second, behaviorEndEntry.branchContext, behaviorEndEntry.second);
}
behavior.second->endEntries.clear();
if (m_Parent->IsPlayer()) continue;
behavior.second->Interrupt();
}
}
void SkillComponent::RegisterCalculatedProjectile(const LWOOBJID projectileId, BehaviorContext* context, const BehaviorBranchContext& branch, const LOT lot, const float maxTime,
const NiPoint3& startPosition, const NiPoint3& velocity, const bool trackTarget, const float trackRadius) {
ProjectileSyncEntry entry;
entry.context = context;
entry.branchContext = branch;
entry.lot = lot;
entry.calculation = true;
entry.time = 0;
entry.maxTime = maxTime;
entry.id = projectileId;
entry.startPosition = startPosition;
entry.lastPosition = startPosition;
entry.velocity = velocity;
entry.trackTarget = trackTarget;
entry.trackRadius = trackRadius;
this->m_managedProjectiles.push_back(entry);
}
bool SkillComponent::CastSkill(const uint32_t skillId, LWOOBJID target, const LWOOBJID optionalOriginatorID) {
uint32_t behaviorId = -1;
// try to find it via the cache
const auto& pair = m_skillBehaviorCache.find(skillId);
// if it's not in the cache look it up and cache it
if (pair == m_skillBehaviorCache.end()) {
auto skillTable = CDClientManager::Instance().GetTable<CDSkillBehaviorTable>();
behaviorId = skillTable->GetSkillByID(skillId).behaviorID;
m_skillBehaviorCache.insert_or_assign(skillId, behaviorId);
} else {
behaviorId = pair->second;
}
// check to see if we got back a valid behavior
if (behaviorId == -1) {
LOG_DEBUG("Tried to cast skill %i but found no behavior", skillId);
return false;
}
return CalculateBehavior(skillId, behaviorId, target, false, false, optionalOriginatorID).success;
}
SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, const uint32_t behaviorId, const LWOOBJID target, const bool ignoreTarget, const bool clientInitalized, const LWOOBJID originatorOverride) {
auto* bitStream = new RakNet::BitStream();
auto* behavior = Behavior::CreateBehavior(behaviorId);
auto* context = new BehaviorContext(originatorOverride != LWOOBJID_EMPTY ? originatorOverride : this->m_Parent->GetObjectID(), true);
context->caster = m_Parent->GetObjectID();
context->skillID = skillId;
context->clientInitalized = clientInitalized;
context->foundTarget = target != LWOOBJID_EMPTY || ignoreTarget || clientInitalized;
behavior->Calculate(context, bitStream, { target, 0 });
for (auto* script : CppScripts::GetEntityScripts(m_Parent)) {
script->OnSkillCast(m_Parent, skillId);
}
if (!context->foundTarget) {
delete bitStream;
delete context;
// Invalid attack
return { false, 0 };
}
this->m_managedBehaviors.insert_or_assign(context->skillUId, context);
if (!clientInitalized) {
// Echo start skill
EchoStartSkill start;
start.iCastType = 0;
start.skillID = skillId;
start.uiSkillHandle = context->skillUId;
start.optionalOriginatorID = context->originator;
start.optionalTargetID = target;
auto* originator = Game::entityManager->GetEntity(context->originator);
if (originator != nullptr) {
start.originatorRot = originator->GetRotation();
}
//start.optionalTargetID = target;
start.sBitStream.assign(reinterpret_cast<char*>(bitStream->GetData()), bitStream->GetNumberOfBytesUsed());
// Write message
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
message.Write(this->m_Parent->GetObjectID());
start.Serialize(&message);
Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
}
context->ExecuteUpdates();
delete bitStream;
// Valid attack
return { true, context->skillTime };
}
void SkillComponent::CalculateUpdate(const float deltaTime) {
if (this->m_managedBehaviors.empty())
return;
for (const auto& managedBehavior : this->m_managedBehaviors) {
if (managedBehavior.second == nullptr) {
continue;
}
managedBehavior.second->CalculateUpdate(deltaTime);
}
for (auto& managedProjectile : this->m_managedProjectiles) {
auto entry = managedProjectile;
if (!entry.calculation) continue;
entry.time += deltaTime;
auto* origin = Game::entityManager->GetEntity(entry.context->originator);
if (origin == nullptr) {
continue;
}
const auto targets = origin->GetTargetsInPhantom();
const auto position = entry.startPosition + (entry.velocity * entry.time);
for (const auto& targetId : targets) {
auto* target = Game::entityManager->GetEntity(targetId);
const auto targetPosition = target->GetPosition();
const auto closestPoint = Vector3::ClosestPointOnLine(entry.lastPosition, position, targetPosition);
const auto distance = Vector3::DistanceSquared(targetPosition, closestPoint);
if (distance > 3 * 3) {
// TODO There is supposed to be an implementation for homing projectiles here
continue;
}
entry.branchContext.target = targetId;
SyncProjectileCalculation(entry);
entry.time = entry.maxTime;
break;
}
entry.lastPosition = position;
managedProjectile = entry;
}
std::vector<ProjectileSyncEntry> valid;
for (auto& entry : this->m_managedProjectiles) {
if (entry.calculation) {
if (entry.time >= entry.maxTime) {
entry.branchContext.target = LWOOBJID_EMPTY;
SyncProjectileCalculation(entry);
continue;
}
}
valid.push_back(entry);
}
this->m_managedProjectiles = valid;
}
void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry) const {
auto* other = Game::entityManager->GetEntity(entry.branchContext.target);
if (other == nullptr) {
if (entry.branchContext.target != LWOOBJID_EMPTY) {
LOG("Invalid projectile target (%llu)!", entry.branchContext.target);
}
return;
}
auto query = CDClientDatabase::CreatePreppedStmt(
"SELECT behaviorID FROM SkillBehavior WHERE skillID = (SELECT skillID FROM ObjectSkills WHERE objectTemplate = ?);");
query.bind(1, static_cast<int>(entry.lot));
auto result = query.execQuery();
if (result.eof()) {
LOG("Failed to find skill id for (%i)!", entry.lot);
return;
}
const auto behaviorId = static_cast<uint32_t>(result.getIntField(0));
result.finalize();
auto* behavior = Behavior::CreateBehavior(behaviorId);
auto* bitStream = new RakNet::BitStream();
behavior->Calculate(entry.context, bitStream, entry.branchContext);
DoClientProjectileImpact projectileImpact;
projectileImpact.sBitStream.assign(reinterpret_cast<char*>(bitStream->GetData()), bitStream->GetNumberOfBytesUsed());
projectileImpact.i64OwnerID = this->m_Parent->GetObjectID();
projectileImpact.i64OrgID = entry.id;
projectileImpact.i64TargetID = entry.branchContext.target;
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
message.Write(this->m_Parent->GetObjectID());
projectileImpact.Serialize(&message);
Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
entry.context->ExecuteUpdates();
delete bitStream;
}
void SkillComponent::HandleUnmanaged(const uint32_t behaviorId, const LWOOBJID target, LWOOBJID source) {
auto* context = new BehaviorContext(source);
context->unmanaged = true;
context->caster = target;
auto* behavior = Behavior::CreateBehavior(behaviorId);
auto* bitStream = new RakNet::BitStream();
behavior->Handle(context, bitStream, { target });
delete bitStream;
delete context;
}
void SkillComponent::HandleUnCast(const uint32_t behaviorId, const LWOOBJID target) {
auto* context = new BehaviorContext(target);
context->caster = target;
auto* behavior = Behavior::CreateBehavior(behaviorId);
behavior->UnCast(context, { target });
delete context;
}
SkillComponent::SkillComponent(Entity* parent): Component(parent) {
this->m_skillUid = 0;
}
SkillComponent::~SkillComponent() {
Reset();
}
void SkillComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
if (bIsInitialUpdate) outBitStream->Write0();
}
/// <summary>
/// Get a unique skill ID for syncing behaviors to the client
/// </summary>
/// <returns>Unique skill ID</returns>
uint32_t SkillComponent::GetUniqueSkillId() {
return ++this->m_skillUid;
}