mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2024-11-22 13:37:22 +00:00
368 lines
8.6 KiB
C++
368 lines
8.6 KiB
C++
#include "BehaviorContext.h"
|
|
#include "Behavior.h"
|
|
#include "BehaviorBranchContext.h"
|
|
#include "EntityManager.h"
|
|
#include "SkillComponent.h"
|
|
#include "Game.h"
|
|
#include "dLogger.h"
|
|
#include "dServer.h"
|
|
#include "PacketUtils.h"
|
|
|
|
#include <sstream>
|
|
|
|
#include "DestroyableComponent.h"
|
|
#include "EchoSyncSkill.h"
|
|
#include "PhantomPhysicsComponent.h"
|
|
#include "RebuildComponent.h"
|
|
#include "eReplicaComponentType.h"
|
|
#include "eConnectionType.h"
|
|
|
|
BehaviorSyncEntry::BehaviorSyncEntry() {
|
|
}
|
|
|
|
BehaviorTimerEntry::BehaviorTimerEntry() {
|
|
}
|
|
|
|
BehaviorEndEntry::BehaviorEndEntry() {
|
|
}
|
|
|
|
uint32_t BehaviorContext::GetUniqueSkillId() const {
|
|
auto* entity = EntityManager::Instance()->GetEntity(this->originator);
|
|
|
|
if (entity == nullptr) {
|
|
Game::logger->Log("BehaviorContext", "Invalid entity for (%llu)!", this->originator);
|
|
|
|
return 0;
|
|
}
|
|
|
|
auto* component = entity->GetComponent<SkillComponent>();
|
|
|
|
if (component == nullptr) {
|
|
Game::logger->Log("BehaviorContext", "No skill component attached to (%llu)!", this->originator);;
|
|
|
|
return 0;
|
|
}
|
|
|
|
return component->GetUniqueSkillId();
|
|
}
|
|
|
|
|
|
void BehaviorContext::RegisterSyncBehavior(const uint32_t syncId, Behavior* behavior, const BehaviorBranchContext& branchContext, const float duration, bool ignoreInterrupts) {
|
|
auto entry = BehaviorSyncEntry();
|
|
|
|
entry.handle = syncId;
|
|
entry.behavior = behavior;
|
|
entry.branchContext = branchContext;
|
|
entry.branchContext.isSync = true;
|
|
entry.ignoreInterrupts = ignoreInterrupts;
|
|
// Add 10 seconds + duration time to account for lag and give clients time to send their syncs to the server.
|
|
constexpr float lagTime = 10.0f;
|
|
entry.time = lagTime + duration;
|
|
|
|
this->syncEntries.push_back(entry);
|
|
}
|
|
|
|
void BehaviorContext::RegisterTimerBehavior(Behavior* behavior, const BehaviorBranchContext& branchContext, const LWOOBJID second) {
|
|
BehaviorTimerEntry entry;
|
|
|
|
entry.time = branchContext.duration;
|
|
entry.behavior = behavior;
|
|
entry.branchContext = branchContext;
|
|
entry.second = second;
|
|
|
|
this->timerEntries.push_back(entry);
|
|
}
|
|
|
|
void BehaviorContext::RegisterEndBehavior(Behavior* behavior, const BehaviorBranchContext& branchContext, const LWOOBJID second) {
|
|
BehaviorEndEntry entry;
|
|
|
|
entry.behavior = behavior;
|
|
entry.branchContext = branchContext;
|
|
entry.second = second;
|
|
entry.start = branchContext.start;
|
|
|
|
this->endEntries.push_back(entry);
|
|
}
|
|
|
|
void BehaviorContext::ScheduleUpdate(const LWOOBJID id) {
|
|
if (std::find(this->scheduledUpdates.begin(), this->scheduledUpdates.end(), id) != this->scheduledUpdates.end()) {
|
|
return;
|
|
}
|
|
|
|
this->scheduledUpdates.push_back(id);
|
|
}
|
|
|
|
void BehaviorContext::ExecuteUpdates() {
|
|
for (const auto& id : this->scheduledUpdates) {
|
|
auto* entity = EntityManager::Instance()->GetEntity(id);
|
|
|
|
if (entity == nullptr) continue;
|
|
|
|
EntityManager::Instance()->SerializeEntity(entity);
|
|
}
|
|
|
|
this->scheduledUpdates.clear();
|
|
}
|
|
|
|
void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream* bitStream) {
|
|
BehaviorSyncEntry entry;
|
|
auto found = false;
|
|
|
|
/*
|
|
* There may be more than one of each handle
|
|
*/
|
|
for (auto i = 0u; i < this->syncEntries.size(); ++i) {
|
|
const auto syncEntry = this->syncEntries.at(i);
|
|
|
|
if (syncEntry.handle == syncId) {
|
|
found = true;
|
|
entry = syncEntry;
|
|
|
|
this->syncEntries.erase(this->syncEntries.begin() + i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
Game::logger->Log("BehaviorContext", "Failed to find behavior sync entry with sync id (%i)!", syncId);
|
|
|
|
return;
|
|
}
|
|
|
|
auto* behavior = entry.behavior;
|
|
const auto branch = entry.branchContext;
|
|
|
|
if (behavior == nullptr) {
|
|
Game::logger->Log("BehaviorContext", "Invalid behavior for sync id (%i)!", syncId);
|
|
|
|
return;
|
|
}
|
|
|
|
behavior->Sync(this, bitStream, branch);
|
|
}
|
|
|
|
|
|
void BehaviorContext::Update(const float deltaTime) {
|
|
for (auto i = 0u; i < this->timerEntries.size(); ++i) {
|
|
auto entry = this->timerEntries.at(i);
|
|
|
|
if (entry.time > 0) {
|
|
entry.time -= deltaTime;
|
|
|
|
this->timerEntries[i] = entry;
|
|
}
|
|
|
|
if (entry.time > 0) {
|
|
continue;
|
|
}
|
|
|
|
entry.behavior->Timer(this, entry.branchContext, entry.second);
|
|
}
|
|
|
|
std::vector<BehaviorTimerEntry> valid;
|
|
|
|
for (const auto& entry : this->timerEntries) {
|
|
if (entry.time <= 0) {
|
|
continue;
|
|
}
|
|
|
|
valid.push_back(entry);
|
|
}
|
|
|
|
this->timerEntries = valid;
|
|
}
|
|
|
|
|
|
void BehaviorContext::SyncCalculation(const uint32_t syncId, const float time, Behavior* behavior, const BehaviorBranchContext& branch, const bool ignoreInterrupts) {
|
|
BehaviorSyncEntry entry;
|
|
|
|
entry.behavior = behavior;
|
|
entry.time = time;
|
|
entry.branchContext = branch;
|
|
entry.handle = syncId;
|
|
entry.ignoreInterrupts = ignoreInterrupts;
|
|
|
|
this->syncEntries.push_back(entry);
|
|
}
|
|
|
|
void BehaviorContext::UpdatePlayerSyncs(float deltaTime) {
|
|
uint32_t i = 0;
|
|
while (i < this->syncEntries.size()) {
|
|
auto& entry = this->syncEntries.at(i);
|
|
|
|
entry.time -= deltaTime;
|
|
|
|
if (entry.time >= 0.0f) {
|
|
i++;
|
|
continue;
|
|
}
|
|
this->syncEntries.erase(this->syncEntries.begin() + i);
|
|
}
|
|
}
|
|
|
|
void BehaviorContext::InvokeEnd(const uint32_t id) {
|
|
std::vector<BehaviorEndEntry> entries;
|
|
|
|
for (const auto& entry : this->endEntries) {
|
|
if (entry.start == id) {
|
|
entry.behavior->End(this, entry.branchContext, entry.second);
|
|
|
|
continue;
|
|
}
|
|
|
|
entries.push_back(entry);
|
|
}
|
|
|
|
this->endEntries = entries;
|
|
}
|
|
|
|
bool BehaviorContext::CalculateUpdate(const float deltaTime) {
|
|
auto any = false;
|
|
|
|
for (auto i = 0u; i < this->syncEntries.size(); ++i) {
|
|
auto entry = this->syncEntries.at(i);
|
|
|
|
if (entry.time > 0) {
|
|
entry.time -= deltaTime;
|
|
|
|
this->syncEntries[i] = entry;
|
|
}
|
|
|
|
if (entry.time > 0) {
|
|
any = true;
|
|
|
|
continue;
|
|
}
|
|
|
|
// Echo sync
|
|
EchoSyncSkill echo;
|
|
|
|
echo.bDone = true;
|
|
echo.uiBehaviorHandle = entry.handle;
|
|
echo.uiSkillHandle = this->skillUId;
|
|
|
|
auto* bitStream = new RakNet::BitStream();
|
|
|
|
// Calculate sync
|
|
entry.behavior->SyncCalculation(this, bitStream, entry.branchContext);
|
|
|
|
if (!clientInitalized) {
|
|
echo.sBitStream.assign((char*)bitStream->GetData(), bitStream->GetNumberOfBytesUsed());
|
|
|
|
// Write message
|
|
RakNet::BitStream message;
|
|
|
|
PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
|
|
message.Write(this->originator);
|
|
echo.Serialize(&message);
|
|
|
|
Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
|
|
}
|
|
|
|
ExecuteUpdates();
|
|
|
|
delete bitStream;
|
|
}
|
|
|
|
std::vector<BehaviorSyncEntry> valid;
|
|
|
|
for (const auto& entry : this->syncEntries) {
|
|
if (entry.time <= 0) {
|
|
continue;
|
|
}
|
|
|
|
valid.push_back(entry);
|
|
}
|
|
|
|
this->syncEntries = valid;
|
|
|
|
return any;
|
|
}
|
|
|
|
void BehaviorContext::Interrupt() {
|
|
std::vector<BehaviorSyncEntry> keptSync{};
|
|
|
|
for (const auto& entry : this->syncEntries) {
|
|
if (!entry.ignoreInterrupts) continue;
|
|
|
|
keptSync.push_back(entry);
|
|
}
|
|
|
|
this->syncEntries = keptSync;
|
|
}
|
|
|
|
void BehaviorContext::Reset() {
|
|
for (const auto& entry : this->timerEntries) {
|
|
entry.behavior->Timer(this, entry.branchContext, entry.second);
|
|
}
|
|
|
|
for (const auto& entry : this->endEntries) {
|
|
entry.behavior->End(this, entry.branchContext, entry.second);
|
|
}
|
|
|
|
this->endEntries.clear();
|
|
this->timerEntries.clear();
|
|
this->syncEntries.clear();
|
|
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<LWOOBJID> targets;
|
|
|
|
if (entity == nullptr) {
|
|
Game::logger->Log("BehaviorContext", "Invalid entity for (%llu)!", this->originator);
|
|
|
|
return targets;
|
|
}
|
|
|
|
if (!ignoreFaction && !includeFaction) {
|
|
for (auto entry : entity->GetTargetsInPhantom()) {
|
|
auto* instance = EntityManager::Instance()->GetEntity(entry);
|
|
|
|
if (instance == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
targets.push_back(entry);
|
|
}
|
|
}
|
|
|
|
if (ignoreFaction || includeFaction || (!entity->HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) && targets.empty())) {
|
|
DestroyableComponent* destroyableComponent;
|
|
if (!entity->TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
|
|
return targets;
|
|
}
|
|
|
|
auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS);
|
|
for (auto* candidate : entities) {
|
|
const auto id = candidate->GetObjectID();
|
|
|
|
if ((id != entity->GetObjectID() || targetSelf) && destroyableComponent->CheckValidity(id, ignoreFaction || includeFaction, targetEnemy, targetFriend)) {
|
|
targets.push_back(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
return targets;
|
|
}
|
|
|
|
|
|
BehaviorContext::BehaviorContext(const LWOOBJID originator, const bool calculation) {
|
|
this->originator = originator;
|
|
this->syncEntries = {};
|
|
this->timerEntries = {};
|
|
|
|
if (calculation) {
|
|
this->skillUId = GetUniqueSkillId();
|
|
} else {
|
|
this->skillUId = 0;
|
|
}
|
|
}
|
|
|
|
BehaviorContext::~BehaviorContext() {
|
|
Reset();
|
|
}
|