diff --git a/_DEMO_DEBUG/GPP_Plugin_d.dll b/_DEMO_DEBUG/GPP_Plugin_d.dll index 42d6a36..a684e18 100644 Binary files a/_DEMO_DEBUG/GPP_Plugin_d.dll and b/_DEMO_DEBUG/GPP_Plugin_d.dll differ diff --git a/_DEMO_DEBUG/GPP_Plugin_d.pdb b/_DEMO_DEBUG/GPP_Plugin_d.pdb index e90e0fb..2bfd416 100644 Binary files a/_DEMO_DEBUG/GPP_Plugin_d.pdb and b/_DEMO_DEBUG/GPP_Plugin_d.pdb differ diff --git a/_DEMO_DEBUG/imgui.ini b/_DEMO_DEBUG/imgui.ini index d90e1e6..cfea17e 100644 --- a/_DEMO_DEBUG/imgui.ini +++ b/_DEMO_DEBUG/imgui.ini @@ -859,13 +859,13 @@ Size=240,520 Collapsed=0 [WORLD INFO [35 FPS]] -Pos=651,10 -Size=240,431 +Pos=710,10 +Size=240,520 Collapsed=0 [WORLD INFO [34 FPS]] -Pos=651,10 -Size=240,431 +Pos=710,10 +Size=240,520 Collapsed=0 [WORLD INFO [33 FPS]] @@ -1973,3 +1973,153 @@ Pos=710,10 Size=240,520 Collapsed=0 +[WORLD INFO [740 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [454 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [429 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [316 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [303 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [242 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [724 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [401 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [390 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [794 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [32 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [29 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [27 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [25 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [23 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [22 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [20 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [21 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [19 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [18 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [17 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [16 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [15 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [14 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [13 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [12 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [11 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [10 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [754 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + +[WORLD INFO [9 FPS]] +Pos=710,10 +Size=240,520 +Collapsed=0 + diff --git a/_DEMO_RELEASE/GPP_Plugin.dll b/_DEMO_RELEASE/GPP_Plugin.dll deleted file mode 100644 index 1823495..0000000 Binary files a/_DEMO_RELEASE/GPP_Plugin.dll and /dev/null differ diff --git a/_DEMO_RELEASE/GPP_Plugin.exp b/_DEMO_RELEASE/GPP_Plugin.exp new file mode 100644 index 0000000..0a70dc6 Binary files /dev/null and b/_DEMO_RELEASE/GPP_Plugin.exp differ diff --git a/_DEMO_RELEASE/GPP_Plugin.lib b/_DEMO_RELEASE/GPP_Plugin.lib new file mode 100644 index 0000000..5874dc4 Binary files /dev/null and b/_DEMO_RELEASE/GPP_Plugin.lib differ diff --git a/project/Behaviour.cpp b/project/Behaviour.cpp index ee737f2..a8fc606 100644 --- a/project/Behaviour.cpp +++ b/project/Behaviour.cpp @@ -93,7 +93,17 @@ namespace BT_Action } BT::State EnableSpin(Blackboard* blackboardPtr) { + IExamInterface* interfacePtr{}; + SteeringPlugin_Output steering{}; + + blackboardPtr->GetData("Interface", interfacePtr); + blackboardPtr->GetData("Steering", steering); + + steering.AutoOrient = true; + steering.AngularVelocity = interfacePtr->Agent_GetInfo().MaxAngularSpeed; + blackboardPtr->ChangeData("Spin", true); + blackboardPtr->ChangeData("Steering", steering); return BT::State::Success; } @@ -104,6 +114,7 @@ namespace BT_Action return BT::State::Success; } + BT::State FindClosestEdge(Blackboard* blackboardPtr, int degree) { IExamInterface* interfacePtr{}; blackboardPtr->GetData("Interface", interfacePtr); @@ -138,6 +149,106 @@ namespace BT_Action return BT::State::Success; } + BT::State SetZombieTarget(Blackboard* blackboardPtr) { + IExamInterface* interfacePtr{}; + blackboardPtr->GetData("Interface", interfacePtr); + + if (interfacePtr->GetEnemiesInFOV().capacity() == 0) { + return BT::State::Failure; + } + + EnemyInfo zombieInfo{}; + float closestZombie{ FLT_MAX }; + + for (const auto zombie : interfacePtr->GetEnemiesInFOV()) { + const float distance{ interfacePtr->Agent_GetInfo().Position.DistanceSquared(zombie.Location) }; + + if (closestZombie < distance) + continue; + + closestZombie = distance; + zombieInfo = zombie; + } + + blackboardPtr->ChangeData("TargetZombie", zombieInfo); + + return BT::State::Success; + } + + BT::State AvoidingZombie(Blackboard* blackboardPtr) { + IExamInterface* interfacePtr{}; + SteeringPlugin_Output steering{}; + + blackboardPtr->GetData("Interface", interfacePtr); + blackboardPtr->GetData("Steering", steering); + + Elite::Vector2 evadeDirection{}; + + for (auto zombie : interfacePtr->GetEnemiesInFOV()) { + Elite::Vector2 currentPos{ interfacePtr->Agent_GetInfo().Position }; + Elite::Vector2 targetPos{ zombie.Location }; + Elite::Vector2 goingAwayVec{ currentPos - targetPos }; + float distance = goingAwayVec.MagnitudeSquared(); + + evadeDirection += goingAwayVec / distance; + } + + steering.LinearVelocity = evadeDirection.GetNormalized() * interfacePtr->Agent_GetInfo().MaxLinearSpeed; + + blackboardPtr->ChangeData("Steering", steering); + + return BT::State::Success; + } + + BT::State RotateToZombie(Blackboard* blackboardPtr) { + IExamInterface* interfacePtr{}; + EnemyInfo zombieInfo{}; + SteeringPlugin_Output steering{}; + + blackboardPtr->GetData("Interface", interfacePtr); + blackboardPtr->GetData("TargetZombie", zombieInfo); + blackboardPtr->GetData("Steering", steering); + + const float maxAngularVelocity{ interfacePtr->Agent_GetInfo().MaxAngularSpeed }; + const float targetAngle{ VectorToOrientation((zombieInfo.Location - interfacePtr->Agent_GetInfo().Position).GetNormalized()) }; + const float angleDiff{ targetAngle - interfacePtr->Agent_GetInfo().Orientation }; + + steering.AngularVelocity = angleDiff * maxAngularVelocity; + + blackboardPtr->ChangeData("Steering", steering); + blackboardPtr->ChangeData("angleDiff", angleDiff); + + return BT::State::Success; + } + + BT::State ReadyToShoot(Blackboard* blackboardPtr, float minAngleDiff) { + float angleDiff{}; + + blackboardPtr->GetData("angleDiff", angleDiff); + + return (std::abs(angleDiff) < minAngleDiff) ? BT::State::Success : BT::State::Failure; + } + + BT::State Shoot(Blackboard* blackboardPtr, eItemType type) { + IExamInterface* interfacePtr{}; + Thinker* thinkerPtr{}; + + blackboardPtr->GetData("Interface", interfacePtr); + blackboardPtr->GetData("Brain", thinkerPtr); + + const auto item = thinkerPtr->FindLeastValueItem(type); + + if (item->ItemInfo.Value <= 0) + return BT::State::Failure; + + if (interfacePtr->Inventory_UseItem(item->invIndex)) { + --item->ItemInfo.Value; + return BT::State::Success; + } + + return BT::State::Failure; + } + BT::State SetItemAsTarget(Blackboard* blackboardPtr) { IExamInterface* interfacePtr{}; blackboardPtr->GetData("Interface", interfacePtr); @@ -150,12 +261,12 @@ namespace BT_Action float closestItem{ FLT_MAX }; for (const auto item : interfacePtr->GetItemsInFOV()) { - const float itemDistance{ interfacePtr->Agent_GetInfo().Position.DistanceSquared(item.Location) }; + const float distance{ interfacePtr->Agent_GetInfo().Position.DistanceSquared(item.Location) }; - if (closestItem < itemDistance) + if (closestItem < distance) continue; - closestItem = itemDistance; + closestItem = distance; targetItem = item; } @@ -304,6 +415,11 @@ namespace BT_Action const Elite::Vector2 pointOnCircle{ playerPos.x + searchRadius * std::cosf(TO_RAD(i)), playerPos.y + searchRadius * std::sinf(TO_RAD(i)) }; const Elite::Vector2 target = interfacePtr->NavMesh_GetClosestPathPoint(pointOnCircle); + + if (target == Elite::Vector2(400, 400)) { + std::cout << pointOnCircle << std::endl; + } + if (pointOnCircle != target) { constexpr float houseOffset{ 5.f }; if (thinkerPtr->CheckIfTargetIsExplored(target, houseOffset)) @@ -319,8 +435,7 @@ namespace BT_Action } if (finalTarget == Elite::Vector2{}) { - finalTarget = Elite::Vector2(randNumRange(-searchRadius, searchRadius), - randNumRange(-searchRadius, searchRadius)); + return BT::State::Failure; } blackboardPtr->ChangeData("Target", finalTarget); @@ -328,6 +443,19 @@ namespace BT_Action return BT::State::Success; } + BT::State FindRandomLocation(Blackboard* blackboardPtr, float randomRadius) { + IExamInterface* interfacePtr{}; + blackboardPtr->GetData("Interface", interfacePtr); + + const Elite::Vector2 playerPos{ interfacePtr->Agent_GetInfo().Position }; + Elite::Vector2 target = Elite::Vector2(playerPos.x + randNumRange(-randomRadius, randomRadius), + playerPos.y + randNumRange(-randomRadius, randomRadius)); + + blackboardPtr->ChangeData("Target", target); + + return BT::State::Success; + } + BT::State GetHouseAsTarget(Blackboard* blackboardPtr, float maxTravelDistance) { IExamInterface* interfacePtr{}; Thinker* thinkerPtr{}; @@ -418,6 +546,29 @@ namespace BT_Condition return false; } + bool SeeZombie(Blackboard* blackboardPtr) { + IExamInterface* interfacePtr{}; + blackboardPtr->GetData("Interface", interfacePtr); + + return interfacePtr->GetEnemiesInFOV().capacity() > 0; + } + + bool HasWeapon(Blackboard* blackboardPtr) { + return ItemInInv(blackboardPtr, eItemType::SHOTGUN) || ItemInInv(blackboardPtr, eItemType::PISTOL); + } + + bool InRange(Blackboard* blackboardPtr, float maxRange) { + IExamInterface* interfacePtr{}; + EnemyInfo zombieInfo{}; + + blackboardPtr->GetData("Interface", interfacePtr); + blackboardPtr->GetData("TargetZombie", zombieInfo); + + const float dist2{ (zombieInfo.Location - interfacePtr->Agent_GetInfo().Position).MagnitudeSquared() }; + + return dist2 <= maxRange * maxRange; + } + bool SeePurgeZone(Blackboard* blackboardPtr) { IExamInterface* interfacePtr{}; blackboardPtr->GetData("Interface", interfacePtr); diff --git a/project/Behaviour.h b/project/Behaviour.h index 5a40cfb..d7413dd 100644 --- a/project/Behaviour.h +++ b/project/Behaviour.h @@ -20,6 +20,12 @@ namespace BT_Action BT::State FindClosestEdge(Blackboard* blackboardPtr, int degree); + BT::State SetZombieTarget(Blackboard* blackboardPtr); + BT::State AvoidingZombie(Blackboard* blackboardPtr); + BT::State RotateToZombie(Blackboard* blackboardPtr); + BT::State ReadyToShoot(Blackboard* blackboardPtr, float minAngleDiff); + BT::State Shoot(Blackboard* blackboardPtr, eItemType type); + BT::State UseItem(Blackboard* blackboardPtr, eItemType type); BT::State SetItemAsTarget(Blackboard* blackboardPtr); @@ -29,11 +35,13 @@ namespace BT_Action BT::State CheckItem(Blackboard* blackboardPtr); BT::State TryFindHouse(Blackboard* blackboardPtr, float searchRadius, int degree); + BT::State FindRandomLocation(Blackboard* blackboardPtr, float randomRadius); BT::State GetHouseAsTarget(Blackboard* blackboardPtr, float maxTravelDistance); BT::State CheckHouses(Blackboard* blackboardPtr); BT::State SetExpireDate(Blackboard* blackboardPtr); BT::State GetInsideTarget(Blackboard* blackboardPtr, float offset); + } namespace BT_Condition @@ -43,6 +51,10 @@ namespace BT_Condition bool SeePurgeZone(Blackboard* blackboardPtr); + bool SeeZombie(Blackboard* blackboardPtr); + bool HasWeapon(Blackboard* blackboardPtr); + bool InRange(Blackboard* blackboardPtr, float maxRange); + bool ItemInInv(Blackboard* blackboardPtr, eItemType type); bool HpUnderThreshold(Blackboard* blackboardPtr, float threshold); bool CheckMinNeededEnergy(Blackboard* blackboardPtr); @@ -57,5 +69,6 @@ namespace BT_Condition bool SeeHouse(Blackboard* blackboardPtr); bool NewHouse(Blackboard* blackboardPtr); bool ReExploreHouse(Blackboard* blackboardPtr); + } diff --git a/project/BigThink.cpp b/project/BigThink.cpp index b3092c9..6874441 100644 --- a/project/BigThink.cpp +++ b/project/BigThink.cpp @@ -4,34 +4,80 @@ #include "Behaviour.h" #include "BehaviourTree.h" +using namespace std::placeholders; + namespace BigThink { - constexpr float HpThreshold{ 8.f }; // TODO: Make this a parameter + BT::Sequence* ZombieHandling() { + constexpr float minShotgunAngleDiff{ .2f }; + constexpr float minPistolAngleDiff{ .1f }; + constexpr float maxShotgunShootRange{ 8.f }; + constexpr float maxPistolShootRange{ 15.f }; + + const std::string ShotgunTimer{ "Shotgun" }; + constexpr bool ShotgunDoOnce{ true }; + + const std::string PistolTimer{ "Pistol" }; + constexpr bool PistolDoOnce{ true }; + + return + new BT::Sequence({ + new BT::Conditional(BT_Condition::SeeZombie), + new BT::Sequence({ + new BT::Action(BT_Action::AvoidingZombie), + new BT::Conditional(BT_Condition::HasWeapon), + new BT::Action(BT_Action::SetZombieTarget), + new BT::Sequence({ + new BT::Action(BT_Action::RotateToZombie), + new BT::Selector({ + new BT::Sequence({ + new BT::Conditional(std::bind(BT_Condition::ItemInInv, _1, eItemType::SHOTGUN)), + new BT::Conditional(std::bind(BT_Condition::InRange, _1, maxShotgunShootRange)), + new BT::Action(std::bind(BT_Action::ReadyToShoot, _1, minShotgunAngleDiff)), + new BT::Conditional(std::bind(BT_Condition::CheckTimer, _1, ShotgunTimer, ShotgunDoOnce)), + new BT::Action(std::bind(BT_Action::Shoot, _1, eItemType::SHOTGUN)), + new BT::Action(std::bind(BT_Action::SetTimer, _1, ShotgunTimer, ShotgunDoOnce)) + }), + new BT::Sequence({ + new BT::Conditional(std::bind(BT_Condition::ItemInInv, _1, eItemType::PISTOL)), + new BT::Conditional(std::bind(BT_Condition::InRange, _1, maxPistolShootRange)), + new BT::Action(std::bind(BT_Action::ReadyToShoot, _1, minPistolAngleDiff)), + new BT::Conditional(std::bind(BT_Condition::CheckTimer, _1, PistolTimer, PistolDoOnce)), + new BT::Action(std::bind(BT_Action::Shoot, _1, eItemType::PISTOL)), + new BT::Action(std::bind(BT_Action::SetTimer, _1, PistolTimer, PistolDoOnce)) + }) + }) + }) + }) + }); + } BT::Sequence* PurgeZoneHandling() { - constexpr int searchDegree{ 45 }; + constexpr int searchDegree{ 5 }; return new BT::Sequence({ new BT::Conditional(BT_Condition::SeePurgeZone), - new BT::Action(std::bind(BT_Action::FindClosestEdge, std::placeholders::_1, searchDegree)), + new BT::Action(std::bind(BT_Action::FindClosestEdge, _1, searchDegree)), new BT::Action(BT_Action::GoToTarget) }); } BT::Selector* ItemHandling() { + constexpr float HpThreshold{ 0.f }; + return new BT::Selector({ new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::ItemInInv, std::placeholders::_1, eItemType::MEDKIT)), - new BT::Conditional(std::bind(BT_Condition::HpUnderThreshold, std::placeholders::_1, HpThreshold)), - new BT::Action(std::bind(BT_Action::UseItem, std::placeholders::_1, eItemType::MEDKIT)) + new BT::Conditional(std::bind(BT_Condition::ItemInInv, _1, eItemType::MEDKIT)), + new BT::Conditional(std::bind(BT_Condition::HpUnderThreshold, _1, HpThreshold)), + new BT::Action(std::bind(BT_Action::UseItem, _1, eItemType::MEDKIT)) }), new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::ItemInInv, std::placeholders::_1, eItemType::FOOD)), + new BT::Conditional(std::bind(BT_Condition::ItemInInv, _1, eItemType::FOOD)), new BT::Conditional(BT_Condition::CheckMinNeededEnergy), - new BT::Action(std::bind(BT_Action::UseItem, std::placeholders::_1, eItemType::FOOD)) + new BT::Action(std::bind(BT_Action::UseItem, _1, eItemType::FOOD)) }) - }); + }); } BT::PartialSequence* PickUpHandling() { @@ -43,7 +89,7 @@ namespace BigThink new BT::Action(BT_Action::GoToTarget), new BT::Selector({ new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, std::placeholders::_1, eItemType::GARBAGE)), + new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, _1, eItemType::GARBAGE)), new BT::Action(BT_Action::DestroyItemOnFloor) }), new BT::Sequence({ @@ -58,19 +104,19 @@ namespace BigThink new BT::Conditional(BT_Condition::InvIsFull), new BT::Selector({ new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, std::placeholders::_1, eItemType::FOOD)), + new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem,_1, eItemType::FOOD)), new BT::Action(BT_Action::CheckItem) }), new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, std::placeholders::_1, eItemType::MEDKIT)), + new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, _1, eItemType::MEDKIT)), new BT::Action(BT_Action::CheckItem) }), new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, std::placeholders::_1, eItemType::SHOTGUN)), + new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, _1, eItemType::SHOTGUN)), new BT::Action(BT_Action::CheckItem) }), new BT::Sequence({ - new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, std::placeholders::_1, eItemType::PISTOL)), + new BT::Conditional(std::bind(BT_Condition::IsTypeOfItem, _1, eItemType::PISTOL)), new BT::Action(BT_Action::CheckItem) }) }) @@ -80,9 +126,10 @@ namespace BigThink } BT::Selector* HouseHandling() { - constexpr float maxTravelDistance{ 100.f }; - constexpr int searchRadius{ 300 }; - constexpr int searchDegree{ 45 }; //TODO + constexpr float maxTravelDistance{ 400.f }; + constexpr int searchRadius{ 500 }; + constexpr int randomRadius{ 50 }; + constexpr int searchDegree{ 5 }; constexpr float InsideOffset{ 5.f }; const std::string BeforeLeavingTimer{ "BeforeLeaving" }; @@ -90,60 +137,70 @@ namespace BigThink return new BT::Selector({ + new BT::Sequence({ + new BT::Conditional(BT_Condition::SeeHouse), + new BT::Action(BT_Action::CheckHouses) + }), new BT::PartialSequence({ new BT::Conditional(BT_Condition::InsideTargetHouse), new BT::Action(BT_Action::SetExpireDate), - new BT::Action(std::bind(BT_Action::SetTimer, std::placeholders::_1, BeforeLeavingTimer, BeforeLeavingDoOnce)), + new BT::Action(std::bind(BT_Action::SetTimer, _1, BeforeLeavingTimer, BeforeLeavingDoOnce)), new BT::Selector({ new BT::PartialSequence({ - new BT::Conditional(std::bind(BT_Condition::CheckTimer, std::placeholders::_1, BeforeLeavingTimer, BeforeLeavingDoOnce)), + new BT::Conditional(std::bind(BT_Condition::CheckTimer, _1, BeforeLeavingTimer, BeforeLeavingDoOnce)), new BT::Selector({ new BT::PartialSequence({ new BT::Conditional(BT_Condition::NewHouse), - new BT::Action(std::bind(BT_Action::GetHouseAsTarget, std::placeholders::_1, maxTravelDistance)), + new BT::Action(std::bind(BT_Action::GetHouseAsTarget, _1, maxTravelDistance)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget), }), + new BT::PartialSequence({ + new BT::Action(std::bind(BT_Action::TryFindHouse, _1, searchRadius, searchDegree)), + new BT::Action(BT_Action::EnableSpin), + new BT::Action(BT_Action::GoToTarget) + }), new BT::PartialSequence({ new BT::Conditional(BT_Condition::ReExploreHouse), - new BT::Action(std::bind(BT_Action::GetHouseAsTarget, std::placeholders::_1, maxTravelDistance)), + new BT::Action(std::bind(BT_Action::GetHouseAsTarget, _1, maxTravelDistance)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget), }), new BT::PartialSequence({ - new BT::Action(std::bind(BT_Action::TryFindHouse, std::placeholders::_1, searchRadius, searchDegree)), + new BT::Action(std::bind(BT_Action::FindRandomLocation, _1, randomRadius)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget) }) }), }), new BT::PartialSequence({ - new BT::Action(std::bind(BT_Action::GetInsideTarget, std::placeholders::_1, InsideOffset)), + new BT::Action(std::bind(BT_Action::GetInsideTarget, _1, InsideOffset)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget) }), }) }), - new BT::Sequence({ - new BT::Conditional(BT_Condition::SeeHouse), - new BT::Action(BT_Action::CheckHouses) - }), new BT::Selector({ new BT::PartialSequence({ new BT::Conditional(BT_Condition::NewHouse), - new BT::Action(std::bind(BT_Action::GetHouseAsTarget, std::placeholders::_1, maxTravelDistance)), + new BT::Action(std::bind(BT_Action::GetHouseAsTarget, _1, maxTravelDistance)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget), }), + new BT::PartialSequence({ + new BT::Action(std::bind(BT_Action::TryFindHouse, _1, searchRadius, searchDegree)), + new BT::Action(BT_Action::EnableSpin), + new BT::Action(BT_Action::GoToTarget) + }), new BT::PartialSequence({ new BT::Conditional(BT_Condition::ReExploreHouse), - new BT::Action(std::bind(BT_Action::GetHouseAsTarget, std::placeholders::_1, maxTravelDistance)), + new BT::Action(std::bind(BT_Action::GetHouseAsTarget, _1, maxTravelDistance)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget), }) }), new BT::PartialSequence({ - new BT::Action(std::bind(BT_Action::TryFindHouse, std::placeholders::_1, searchRadius, searchDegree)), + new BT::Action(std::bind(BT_Action::FindRandomLocation, _1, randomRadius)), new BT::Action(BT_Action::EnableSpin), new BT::Action(BT_Action::GoToTarget) }) diff --git a/project/BigThink.h b/project/BigThink.h index cab09db..0fda976 100644 --- a/project/BigThink.h +++ b/project/BigThink.h @@ -10,6 +10,7 @@ namespace BT namespace BigThink { + BT::Sequence* ZombieHandling(); BT::Sequence* PurgeZoneHandling(); BT::Selector* ItemHandling(); BT::PartialSequence* PickUpHandling(); diff --git a/project/SurvivalAgentPlugin.cpp b/project/SurvivalAgentPlugin.cpp index 8383bd5..42f2ed0 100644 --- a/project/SurvivalAgentPlugin.cpp +++ b/project/SurvivalAgentPlugin.cpp @@ -29,6 +29,7 @@ void SurvivalAgentPlugin::Initialize(IBaseInterface* pInterface, PluginInfo& inf Blackboard* blackboardPtr{ CreateBlackboard() }; m_BehaviourTree = new BT::BehaviorTree(blackboardPtr, new BT::Selector({ + BigThink::ZombieHandling(), BigThink::PurgeZoneHandling(), BigThink::ItemHandling(), BigThink::PickUpHandling(), @@ -51,17 +52,24 @@ Blackboard* SurvivalAgentPlugin::CreateBlackboard() { blackboardPtr->AddData("MaxFailSafe", 2.f); blackboardPtr->AddData("FailSafeDoOnce", false); + blackboardPtr->AddData("TargetZombie", EnemyInfo{}); + blackboardPtr->AddData("angleDiff", float{}); + blackboardPtr->AddData("TimerShotgun", std::chrono::steady_clock::time_point{}); + blackboardPtr->AddData("TimerShotgunDoOnce", false); + blackboardPtr->AddData("MaxTimeShotgun", 1.f); + blackboardPtr->AddData("TimerPistol", std::chrono::steady_clock::time_point{}); + blackboardPtr->AddData("TimerPistolDoOnce", false); + blackboardPtr->AddData("MaxTimePistol", 1.f); + blackboardPtr->AddData("TargetItem", ItemInfo{}); blackboardPtr->AddData("NextFreeSlot", 0); blackboardPtr->AddData("TargetHouse", HouseInfo{}); blackboardPtr->AddData("TimerBeforeLeaving", std::chrono::steady_clock::time_point{}); blackboardPtr->AddData("TimerBeforeLeavingDoOnce", false); - blackboardPtr->AddData("MaxTimeBeforeLeaving", 5.f); + blackboardPtr->AddData("MaxTimeBeforeLeaving", 3.f); return blackboardPtr; - - } void SurvivalAgentPlugin::UpdateBlackboard(const SteeringPlugin_Output& steering) { @@ -105,7 +113,7 @@ void SurvivalAgentPlugin::InitGameDebugParams(GameDebugParams& params) params.SpawnPurgeZonesOnMiddleClick = true; params.PrintDebugMessages = true; params.ShowDebugItemNames = true; - params.Seed = 0; //-1 = don't set seed. Any other number = fixed seed //TIP: use Seed = int(time(nullptr)) for pure randomness + params.Seed = -1; //-1 = don't set seed. Any other number = fixed seed //TIP: use Seed = int(time(nullptr)) for pure randomness } void SurvivalAgentPlugin::Update_Debug(float dt) @@ -176,8 +184,8 @@ void SurvivalAgentPlugin::Update_Debug(float dt) //This function calculates the new SteeringOutput, called once per frame SteeringPlugin_Output SurvivalAgentPlugin::UpdateSteering(float dt) { - auto steering = SteeringPlugin_Output(); - bool spin{}; + auto steering = SteeringPlugin_Output(Elite::Vector2{}, m_pInterface->Agent_GetInfo().MaxAngularSpeed, true, false); + bool spin{ false }; UpdateBlackboard(steering); @@ -188,7 +196,6 @@ SteeringPlugin_Output SurvivalAgentPlugin::UpdateSteering(float dt) if (spin) { steering.AutoOrient = false; - steering.AngularVelocity = 3.14f; } if (m_GrabItem) { @@ -203,6 +210,7 @@ SteeringPlugin_Output SurvivalAgentPlugin::UpdateSteering(float dt) return steering; + } //This function should only be used for rendering debug elements @@ -210,6 +218,13 @@ void SurvivalAgentPlugin::Render(float dt) const { //This Render function should only contain calls to Interface->Draw_... functions m_pInterface->Draw_SolidCircle(m_Target, .7f, { 0,0 }, { 1, 0, 0 }); + + m_pInterface->Draw_Circle(m_pInterface->Agent_GetInfo().Position, 500.f, { 1.f, 0.f, 0 }); + m_pInterface->Draw_Circle(m_pInterface->Agent_GetInfo().Position, 400.f, { 1.f, 1.f, 0 }); + m_pInterface->Draw_Circle(m_pInterface->Agent_GetInfo().Position, 50.f, { 1.f, 1.f, 1.f }); + m_pInterface->Draw_Circle(m_pInterface->Agent_GetInfo().Position, 15.f, { 0.f, 1.f, 1.f }); + m_pInterface->Draw_Circle(m_pInterface->Agent_GetInfo().Position, 8.f, { 0.f, 1.f, 1.f }); + }