db/d1d/_war_scene_a_i_8cpp_source.html

#include "Headers/WarScene.h"

#include "Headers/WarSceneAIProcessor.h"


#include "AI/Headers/AIManager.h"

#include "Graphs/Headers/SceneGraph.h"

#include "GUI/Headers/GUIMessageBox.h"

#include "Managers/Headers/ProjectManager.h"

#include "Core/Headers/PlatformContext.h"

#include "Core/Time/Headers/ApplicationTimer.h"

#include "Dynamics/Entities/Units/Headers/NPC.h"

#include "ECS/Components/Headers/UnitComponent.h"

#include "ECS/Components/Headers/TransformComponent.h"

#include "ECS/Components/Headers/RigidBodyComponent.h"

#include "AI/PathFinding/NavMeshes/Headers/NavMesh.h"

#include "Core/Headers/Application.h"


namespace Divide {


namespace {

    bool g_navMeshStarted = false;

}


void WarScene::printMessage(const U8 eventId, const string& unitName) const {

    string eventName;

    switch (eventId) {

        case 0:

          eventName = "Captured flag";

          break;

        case 1:

          eventName = "Recovered flag";

          break;

        default:

          eventName = "Unknown!";

          break;

    }


    U32 elapsedTimeMinutes = Time::MicrosecondsToSeconds<U32>(_elapsedGameTime) / 60 % 60;

    U32 elapsedTimeSeconds = Time::MicrosecondsToSeconds<U32>(_elapsedGameTime) % 60;


    Console::d_printfn(Util::StringFormat("[GAME TIME: {}:{}][{}]: {}", elapsedTimeMinutes, elapsedTimeSeconds, eventName.c_str(), unitName.c_str()).c_str());

}


void WarScene::checkGameCompletion() {

    bool restartGame = false;

    bool timeReason = false;

    if (AI::WarSceneAIProcessor::getScore(0) == _scoreLimit ||

        AI::WarSceneAIProcessor::getScore(1) == _scoreLimit) {

        _elapsedGameTime = 0;

        if (_scoreLimit == 3) {

            _scoreLimit = 5;

            _timeLimitMinutes = 8;

            restartGame = true;

        } else if (_scoreLimit == 5) {

            _scoreLimit = 20;

            _timeLimitMinutes = 30;

            restartGame = true;

        }

        else if (_scoreLimit == 20) {

            if (_runCount == 1) {

                _scoreLimit = 3;

                _timeLimitMinutes = 5;

                _runCount = 2;

                restartGame = true;

            } else if (_runCount == 2) {

                _context.app().RequestShutdown(false);

            }

        }

    }


    const U32 elapsedTimeMinutes = Time::MicrosecondsToSeconds<U32>(_elapsedGameTime) / 60 % 60;

    if (elapsedTimeMinutes >= _timeLimitMinutes) {

        timeReason = true;

        if (_timeLimitMinutes == 5) {

            _timeLimitMinutes = 8;

            _scoreLimit = 5;

        } else if (_timeLimitMinutes == 8) {

            _timeLimitMinutes = 30;

            _scoreLimit = 20;

        } else if (_timeLimitMinutes == 30) {

            if (_runCount == 1) {

                _timeLimitMinutes = 5;

                _scoreLimit = 3;

                _runCount = 2;

            }

            else if (_runCount == 2) {

                _context.app().RequestShutdown(false);

            }

        }

        restartGame = true;

    }


    if (restartGame) {

        _elapsedGameTime = 0;

        Console::d_printfn(Util::StringFormat("\n\nRESTARTING GAME!. Reason: {} \n\n", timeReason ? "TIME" : "SCORE").c_str());

        AI::WarSceneAIProcessor::resetScore(0);

        AI::WarSceneAIProcessor::resetScore(1);

        if (timeReason) {

            _resetUnits = true;

            for (U8 i = 0; i < 2; ++i) {

                TransformComponent* flagtComp = _flag[i]->get<TransformComponent>();

                flagtComp->popTransforms();

                _flag[i]->setParent(_sceneGraph->getRoot());

                flagtComp->setPosition(vec3<F32>(25.0f, 0.1f, i == 0 ? -206.0f : 206.0f));

            }

            AI::WarSceneAIProcessor::reset();

            AI::WarSceneAIProcessor::registerFlags(_flag[0], _flag[1]);

        }

    }

}


void WarScene::registerPoint(const U16 teamID, const string& unitName) {

    if (!_resetUnits)

    {

        _resetUnits = true;


        for (U8 i = 0; i < 2; ++i) {

            if ( _flag[i] != nullptr )

            {

                TransformComponent* flagtComp = _flag[i]->get<TransformComponent>();

                WAIT_FOR_CONDITION(!flagtComp->popTransforms());

                _flag[i]->setParent(_sceneGraph->getRoot());

                flagtComp->setPosition(vec3<F32>(25.0f, 0.1f, i == 0 ? -206.0f : 206.0f));

            }

        }

        AI::WarSceneAIProcessor::reset();

        AI::WarSceneAIProcessor::incrementScore(teamID);

        AI::WarSceneAIProcessor::registerFlags(_flag[0], _flag[1]);


        U32 elapsedTimeMinutes = Time::MicrosecondsToSeconds<U32>(_elapsedGameTime) / 60 % 60;

        U32 elapsedTimeSeconds = Time::MicrosecondsToSeconds<U32>(_elapsedGameTime) % 60;

        Console::d_printfn(Util::StringFormat("[GAME TIME: {}:{}][TEAM {} REGISTER POINT]: {}", elapsedTimeMinutes, elapsedTimeSeconds, teamID == 0 ? "A" : "B", unitName.c_str()).c_str());

        checkGameCompletion();

    }

}


bool WarScene::initializeAI(bool /*continueOnErrors*/) {

    //------------------------Artificial Intelligence------------------------//

    // Create 2 AI teams

    for (U8 i = 0; i < 2; ++i)

    {

        _faction[i] = _aiManager->registerTeam(i);

    }

    // Make the teams fight each other

    _faction[0]->addEnemyTeam(_faction[1]->teamID());

    _faction[1]->addEnemyTeam(_faction[0]->teamID());


    //if (addUnits())

    {

        //_sceneGraph->findNode("Soldier1")->setActive(false);

        //_sceneGraph->findNode("Soldier2")->setActive(false);

        //_sceneGraph->findNode("Soldier3")->setActive(false);

        return true;

    }


    //return false;

}


bool WarScene::removeUnits()

{

    WAIT_FOR_CONDITION(!_aiManager->updating());

    for (U8 i = 0; i < 2; ++i)

    {

        for (SceneGraphNode* npc : _armyNPCs[i])

        {

            _aiManager->unregisterEntity(npc->get<UnitComponent>()->getUnit<NPC>()->getAIEntity());

            _sceneGraph->removeNode(npc);

        }

        _armyNPCs[i].clear();

    }


    return true;

}


bool WarScene::addUnits() {

    using namespace AI;


    // Go near the enemy flag.

    // The enemy flag will never be at the home base, because that is a scoring condition

    WarSceneAction approachEnemyFlag(ActionType::APPROACH_ENEMY_FLAG, "ApproachEnemyFlag");

    approachEnemyFlag.setPrecondition(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(false));

    approachEnemyFlag.setEffect(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(true));

    approachEnemyFlag.setEffect(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(false));


    WarSceneAction protectFlagInBase(ActionType::APPROACH_ENEMY_FLAG, "ProtectFlagInBase");

    protectFlagInBase.setPrecondition(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(false));

    protectFlagInBase.setPrecondition(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));

    protectFlagInBase.setEffect(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(true));


    // Grab the enemy flag only if we do not already have it and if we are near it

    // The enemy flag will never be at the home base, because that is a scoring condition

    WarSceneAction captureEnemyFlag(ActionType::CAPTURE_ENEMY_FLAG, "CaptureEnemyFlag");

    captureEnemyFlag.setPrecondition(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(true));

    captureEnemyFlag.setPrecondition(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(false));

    captureEnemyFlag.setPrecondition(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(false));

    captureEnemyFlag.setEffect(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(true));


    // Kill the enemy flag carrier to recover our own flag and return it to base

    WarSceneAction recoverFlag(ActionType::RECOVER_FLAG, "RecoverFlag");

    recoverFlag.setPrecondition(GOAPFact(Fact::ENEMY_HAS_FLAG), GOAPValue(true));

    recoverFlag.setPrecondition(GOAPFact(Fact::ENEMY_DEAD), GOAPValue(true));

    recoverFlag.setEffect(GOAPFact(Fact::ENEMY_HAS_FLAG), GOAPValue(false));


    // A general purpose "go home" action

    WarSceneAction returnToBase(ActionType::RETURN_TO_BASE, "ReturnToBase");

    returnToBase.setPrecondition(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(false));

    returnToBase.setEffect(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));


    // We can only score if we and both flags are in the same base location

    WarSceneAction scoreEnemyFlag(ActionType::SCORE_FLAG, "ScoreEnemyFlag");

    scoreEnemyFlag.setPrecondition(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));

    scoreEnemyFlag.setPrecondition(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(true));

    scoreEnemyFlag.setPrecondition(GOAPFact(Fact::ENEMY_HAS_FLAG), GOAPValue(false));

    scoreEnemyFlag.setEffect(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(false));


    // Do nothing, but do nothing at home

    WarSceneAction idleAction(ActionType::IDLE, "Idle");

    idleAction.setPrecondition(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));

    idleAction.setEffect(GOAPFact(Fact::IDLING), GOAPFact(true));


    // Kill stuff in lack of a better occupation

    WarSceneAction attackAction(ActionType::ATTACK_ENEMY, "Attack");

    attackAction.setPrecondition(GOAPFact(Fact::ENEMY_DEAD), GOAPValue(false));

    attackAction.setEffect(GOAPFact(Fact::ENEMY_DEAD), GOAPValue(true));


    GOAPGoal recoverOwnFlag("Recover flag", to_base(WarSceneOrder::WarOrder::RECOVER_FLAG));

    recoverOwnFlag.setVariable(GOAPFact(Fact::ENEMY_HAS_FLAG), GOAPValue(false));


    GOAPGoal captureFlag("Capture enemy flag", to_base(WarSceneOrder::WarOrder::CAPTURE_ENEMY_FLAG));

    captureFlag.setVariable(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(true));

    captureFlag.setVariable(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));


    GOAPGoal scoreFlag("Score", to_base(WarSceneOrder::WarOrder::SCORE_ENEMY_FLAG));

    scoreFlag.setVariable(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(false));


    GOAPGoal idle("Idle", to_base(WarSceneOrder::WarOrder::IDLE));

    idle.setVariable(GOAPFact(Fact::IDLING), GOAPValue(true));


    GOAPGoal killEnemy("Kill", to_base(WarSceneOrder::WarOrder::KILL_ENEMY));

    killEnemy.setVariable(GOAPFact(Fact::ENEMY_DEAD), GOAPValue(true));


    GOAPGoal protectFlagCarrier("Protect Flag Carrier", to_base(WarSceneOrder::WarOrder::PROTECT_FLAG_CARRIER));

    protectFlagCarrier.setVariable(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(true));


    std::array<GOAPPackage,  to_base(WarSceneAIProcessor::AIType::COUNT)> goapPackages;

    for (GOAPPackage& goapPackage : goapPackages) {

        goapPackage._worldState.setVariable(GOAPFact(Fact::AT_HOME_BASE), GOAPValue(true));

        goapPackage._worldState.setVariable(GOAPFact(Fact::ENEMY_DEAD), GOAPValue(false));

        goapPackage._worldState.setVariable(GOAPFact(Fact::ENEMY_HAS_FLAG), GOAPValue(false));

        goapPackage._worldState.setVariable(GOAPFact(Fact::HAS_ENEMY_FLAG), GOAPValue(false));

        goapPackage._worldState.setVariable(GOAPFact(Fact::IDLING), GOAPValue(true));

        goapPackage._worldState.setVariable(GOAPFact(Fact::NEAR_ENEMY_FLAG), GOAPValue(false));


        goapPackage._actionSet.push_back(idleAction);

        goapPackage._actionSet.push_back(attackAction);

        goapPackage._actionSet.push_back(recoverFlag);

        goapPackage._actionSet.push_back(protectFlagInBase);

        goapPackage._goalList.push_back(idle);

        goapPackage._goalList.push_back(killEnemy);

        goapPackage._goalList.push_back(recoverOwnFlag);

    }


    GOAPPackage& lightPackage = goapPackages[to_base(WarSceneAIProcessor::AIType::LIGHT)];

    GOAPPackage& heavyPackage = goapPackages[to_base(WarSceneAIProcessor::AIType::HEAVY)];


    heavyPackage._actionSet.push_back(approachEnemyFlag);

    heavyPackage._actionSet.push_back(captureEnemyFlag);

    heavyPackage._actionSet.push_back(returnToBase);

    heavyPackage._actionSet.push_back(scoreEnemyFlag);

    lightPackage._actionSet.push_back(approachEnemyFlag);


    heavyPackage._goalList.push_back(captureFlag);

    heavyPackage._goalList.push_back(scoreFlag);

    heavyPackage._goalList.push_back(protectFlagCarrier);

    lightPackage._goalList.push_back(protectFlagCarrier);


#if 1

    SceneGraphNode* lightNode(_sceneGraph->findNode("Soldier1"));

    SceneGraphNode* animalNode(_sceneGraph->findNode("Soldier2"));

    SceneGraphNode* heavyNode(_sceneGraph->findNode("Soldier3"));


    const SceneNodeHandle lightNodeMesh = lightNode->handle();

    const SceneNodeHandle animalNodeMesh = animalNode->handle();

    const SceneNodeHandle heavyNodeMesh = heavyNode->handle();


    AIEntity* aiSoldier = nullptr;


    vec3<F32> currentScale;

    string currentName;


    constexpr U32 normalMask = to_base(ComponentType::NAVIGATION) |

                               to_base(ComponentType::TRANSFORM) |

                               to_base(ComponentType::RIGID_BODY) |

                               to_base(ComponentType::BOUNDS) |

                               to_base(ComponentType::RENDERING) |

                               to_base(ComponentType::UNIT) |

                               to_base(ComponentType::SELECTION) |

                               to_base(ComponentType::NETWORKING);


    SceneGraphNode* root = _sceneGraph->getRoot();

    for (I32 k = 0; k < 2; ++k)

    {

        for (I32 i = 0; i < 15; ++i)

        {

            F32 speed = Metric::Base(-1.0f);

            F32 acc = Metric::Base(-1.0f);


            F32 zFactor = 0.0f;

            I32 damage = 5;

            AI::WarSceneAIProcessor::AIType type;


            SceneGraphNodeDescriptor npcNodeDescriptor;

            npcNodeDescriptor._serialize = false;

            if (IS_IN_RANGE_INCLUSIVE(i, 0, 4))

            {

                npcNodeDescriptor._nodeHandle = lightNodeMesh;

                currentScale = lightNode->get<TransformComponent>()->getWorldScale();

                Util::StringFormat( currentName, "Soldier_1_{}_{}", k, i );

                speed = Metric::Base(Random(6.5f, 9.5f));

                acc = Metric::Base(Random(4.5f, 8.0f));

                type = AI::WarSceneAIProcessor::AIType::LIGHT;

            }

            else if (IS_IN_RANGE_INCLUSIVE(i, 5, 9))

            {

                npcNodeDescriptor._nodeHandle = animalNodeMesh;

                currentScale = animalNode->get<TransformComponent>()->getWorldScale();

                Util::StringFormat( currentName, "Soldier_2_{}_{}", k, i % 5 );

                speed = Metric::Base(Random(8.5f, 11.5f));

                acc = Metric::Base(Random(6.0f, 9.0f));

                zFactor = 1.0f;

                type = AI::WarSceneAIProcessor::AIType::ANIMAL;

                damage = 10;

            }

            else

            {

                npcNodeDescriptor._nodeHandle = heavyNodeMesh;

                currentScale = heavyNode->get<TransformComponent>()->getWorldScale();

                Util::StringFormat( currentName, "Soldier_3_{}_{}", k, i % 10 );

                speed = Metric::Base(Random(4.5f, 7.5f));

                acc = Metric::Base(Random(4.0f, 6.5f));

                zFactor = 2.0f;

                type = AI::WarSceneAIProcessor::AIType::HEAVY;

                damage = 15;

            }


            npcNodeDescriptor._usageContext = NodeUsageContext::NODE_DYNAMIC;

            npcNodeDescriptor._componentMask = normalMask | to_base(ComponentType::SELECTION);

            npcNodeDescriptor._name = currentName;


            SceneGraphNode* currentNode = root->addChildNode(npcNodeDescriptor);


            currentNode->get<RigidBodyComponent>()->physicsCollisionGroup(PhysicsGroup::GROUP_KINEMATIC);


            TransformComponent* tComp = currentNode->get<TransformComponent>();

            tComp->setScale(currentScale);


            if (k == 0)

            {

                zFactor *= -25;

                zFactor -= 200;

                tComp->translateX(Metric::Base(-25.0f));

            }

            else

            {

                zFactor *= 25;

                zFactor += 200;

                tComp->rotateY(Angle::DEGREES<F32>(180.0f));

                tComp->translateX(Metric::Base(100.0f));

                tComp->translateX(Metric::Base(25.0f));

            }


            tComp->setPosition(vec3<F32>(Metric::Base(-125.0f + 25 * (i % 5)),

                                         Metric::Base(-0.01f),

                                         Metric::Base(zFactor)));


            std::shared_ptr<NPC> soldier = std::make_shared<NPC>( tComp->getWorldPosition(), currentNode->name() );

            soldier->setAttribute(to_base(AI::UnitAttributes::HEALTH_POINTS), 100);

            soldier->setAttribute(to_base(AI::UnitAttributes::DAMAGE), damage);

            soldier->setAttribute(to_base(AI::UnitAttributes::ALIVE_FLAG), 1);

            soldier->setMovementSpeed(speed);

            soldier->setAcceleration(acc);


            aiSoldier = soldier->getAIEntity();

            if (!aiSoldier->addSensor( AI::SensorType::VISUAL_SENSOR ))

            {

                DIVIDE_UNEXPECTED_CALL();

            }


            AI::WarSceneAIProcessor* brain = new AI::WarSceneAIProcessor( type, *_aiManager );

            // GOAP

            brain->registerGOAPPackage( goapPackages[to_U32( type )] );

            if (!aiSoldier->setAndSurrenderAIProcessor( brain ))

            {

                DIVIDE_UNEXPECTED_CALL();

            }


            currentNode->get<UnitComponent>()->setUnit(soldier);

            _armyNPCs[k].push_back(currentNode);

            _aiManager->registerEntity(k, aiSoldier);


        }

    }


    //----------------------- AI controlled units ---------------------//

    return !(_armyNPCs[0].empty() || _armyNPCs[1].empty());

#else

    return true;

#endif

}


AI::AIEntity* WarScene::findAI(SceneGraphNode* node) {

    const I64 targetGUID = node->getGUID();


    for (U8 i = 0; i < 2; ++i) {

        for (SceneGraphNode* npc : _armyNPCs[i]) {

            if (npc->getGUID() == targetGUID) {

                return npc->get<UnitComponent>()->getUnit<NPC>()->getAIEntity();

            }

        }

    }


    return nullptr;

}


bool WarScene::resetUnits() {

    _aiManager->pauseUpdate(true);

    bool state = false;

    if (removeUnits()) {

       state = addUnits();

    }

    _aiManager->pauseUpdate(false);

    return state;

}


bool WarScene::deinitializeAI(bool /*continueOnErrors*/) {

    _aiManager->pauseUpdate(true);

    if (removeUnits())

    {

        for (U8 i = 0; i < 2; ++i)

        {

            if (_aiManager->unregisterTeam(i))

            {

                _faction[i] = nullptr;

            }

            else

            {

                DIVIDE_UNEXPECTED_CALL();

            }

        }

        return true;

    }


    return false;

}


void WarScene::startSimulation(I64 /*btnGUID*/)

{

    if (g_navMeshStarted || _armyNPCs[0].empty()) {

        return;

    }


    g_navMeshStarted = true;


    _aiManager->pauseUpdate(true);

    _infoBox->setTitle("NavMesh state");

    _infoBox->setMessageType(GUIMessageBox::MessageType::MESSAGE_INFO);

    bool previousMesh = false;

    bool loadedFromFile = true;

    const U64 currentTime = Time::App::ElapsedMicroseconds();

    const U64 diffTime = currentTime - _lastNavMeshBuildTime;


    AI::AIEntity* aiEntity = _armyNPCs[0][0]->get<UnitComponent>()->getUnit<NPC>()->getAIEntity();


    if (_lastNavMeshBuildTime == 0UL || diffTime > Time::SecondsToMicroseconds(10))

    {

        const AI::AIEntity::PresetAgentRadius radius = aiEntity->getAgentRadiusCategory();


        AI::Navigation::NavigationMesh* navMesh =  _aiManager->getNavMesh(radius);

        if (navMesh)

        {

            previousMesh = true;

            _aiManager->destroyNavMesh( radius );

        }


        navMesh = _aiManager->addNavMesh(_context, *_parent.parent().recast(), *this, radius);

        navMesh->setFileName(resourceName());


        if (!navMesh->load(_sceneGraph->getRoot()))

        {

            loadedFromFile = false;

            navMesh->build(_sceneGraph->getRoot(),

            [this](AI::Navigation::NavigationMesh*)

            {

                _aiManager->toggleNavMeshDebugDraw(true);

                g_navMeshStarted = false;

            });

        }

        else

        {

            if constexpr(Config::Build::IS_DEBUG_BUILD)

            {

                navMesh->debugDraw(true);

            }

        }


        if (previousMesh) {

            if (loadedFromFile) {

                _infoBox->setMessage(

                    "Re-loaded the navigation mesh from file!");

            }

            else {

                _infoBox->setMessage(

                    "Re-building the navigation mesh in a background thread!");

            }

        }

        else {

            if (loadedFromFile) {

                _infoBox->setMessage("Navigation mesh loaded from file!");

            }

            else {

                _infoBox->setMessage(

                    "Navigation mesh building in a background thread!");

            }

        }

        //_infoBox->show();

        _lastNavMeshBuildTime = currentTime;

        for (U8 i = 0; i < 2; ++i) {

            _faction[i]->clearOrders();

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::CAPTURE_ENEMY_FLAG));

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::SCORE_ENEMY_FLAG));

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::IDLE));

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::KILL_ENEMY));

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::PROTECT_FLAG_CARRIER));

            _faction[i]->addOrder(std::make_shared<AI::WarSceneOrder>(

                AI::WarSceneOrder::WarOrder::RECOVER_FLAG));

        }

    } else {

        string info(

            "Can't reload the navigation mesh this soon.\n Please wait \\[ ");

        info.append(

            Util::to_string(Time::MicrosecondsToSeconds<I32>(diffTime)));

        info.append(" ] seconds more!");


        _infoBox->setMessage(info);

        _infoBox->setMessageType(GUIMessageBox::MessageType::MESSAGE_WARNING);

        _infoBox->show();

    }


    _aiManager->pauseUpdate(false);

}


}  // namespace Divide

AIManager.h

Application.h

ApplicationTimer.h

WAIT_FOR_CONDITION
#define WAIT_FOR_CONDITION(...)
Definition: ConditionalWait.h:65

GUIMessageBox.h

NPC.h

NavMesh.h

PlatformContext.h

DIVIDE_UNEXPECTED_CALL
#define DIVIDE_UNEXPECTED_CALL()
Definition: PlatformDefines.h:737

ProjectManager.h

RigidBodyComponent.h

SceneGraph.h

TransformComponent.h

UnitComponent.h

WarScene.h

WarSceneAIProcessor.h

Divide::AI::AIEntity
Based on OgreCrowd.
Definition: AIEntity.h:60

Divide::AI::AIEntity::setAndSurrenderAIProcessor
bool setAndSurrenderAIProcessor(AIProcessor *processor)
Definition: AIEntity.cpp:139

Divide::AI::AIEntity::addSensor
bool addSensor(SensorType type)
Definition: AIEntity.cpp:117

Divide::AI::AIEntity::PresetAgentRadius
PresetAgentRadius
Definition: AIEntity.h:63

Divide::AI::AIEntity::getAgentRadiusCategory
PresetAgentRadius getAgentRadiusCategory() const noexcept
The radius category of this character.
Definition: AIEntity.h:105

Divide::AI::AITeam::addOrder
void addOrder(const OrderPtr &order)
Definition: AITeam.h:110

Divide::AI::AITeam::clearOrders
void clearOrders()
Definition: AITeam.h:105

Divide::AI::AITeam::addEnemyTeam
bool addEnemyTeam(U32 enemyTeamID)
Definition: AITeam.cpp:192

Divide::AI::GOAPGoal
Definition: GOAPInterface.h:56

Divide::AI::Navigation::NavigationMesh
Definition: NavMesh.h:113

Divide::AI::Navigation::NavigationMesh::build
bool build(SceneGraphNode *sgn, CreationCallback creationCompleteCallback, bool threaded=true)
Definition: NavMesh.cpp:174

Divide::AI::Navigation::NavigationMesh::debugDraw
void debugDraw(const bool state) noexcept
Definition: NavMesh.h:143

Divide::AI::Navigation::NavigationMesh::setFileName
void setFileName(const Str< 256 > &fileName)
Definition: NavMesh.h:128

Divide::AI::Navigation::NavigationMesh::load
bool load(const SceneGraphNode *sgn)
Load a saved NavigationMesh from a file.
Definition: NavMesh.cpp:701

Divide::AI::WarSceneAIProcessor
Definition: WarSceneAIProcessor.h:178

Divide::AI::WarSceneAIProcessor::registerGOAPPackage
void registerGOAPPackage(const GOAPPackage &package)
Definition: WarSceneAIProcessor.cpp:948

Divide::AI::WarSceneAIProcessor::getScore
static U8 getScore(const U16 teamID)
Definition: WarSceneAIProcessor.h:212

Divide::AI::WarSceneAIProcessor::resetScore
static void resetScore(const U8 teamID)
Definition: WarSceneAIProcessor.h:221

Divide::AI::WarSceneAIProcessor::reset
static void reset()
Definition: WarSceneAIProcessor.cpp:79

Divide::AI::WarSceneAIProcessor::registerFlags
static void registerFlags(SceneGraphNode *flag1, SceneGraphNode *flag2)
Definition: WarSceneAIProcessor.h:199

Divide::AI::WarSceneAIProcessor::incrementScore
static void incrementScore(const U16 teamID)
Definition: WarSceneAIProcessor.h:217

Divide::AI::WarSceneAIProcessor::AIType
AIType
Definition: WarSceneAIProcessor.h:183

Divide::AI::WarSceneAIProcessor::AIType::ANIMAL
@ ANIMAL

Divide::AI::WarSceneAIProcessor::AIType::HEAVY
@ HEAVY

Divide::AI::WarSceneAIProcessor::AIType::LIGHT
@ LIGHT

Divide::AI::WarSceneAction
Definition: WarSceneActions.h:84

Divide::AI::WarSceneOrder::WarOrder::RECOVER_FLAG
@ RECOVER_FLAG

Divide::AI::WarSceneOrder::WarOrder::PROTECT_FLAG_CARRIER
@ PROTECT_FLAG_CARRIER

Divide::AI::WarSceneOrder::WarOrder::IDLE
@ IDLE

Divide::AI::WarSceneOrder::WarOrder::SCORE_ENEMY_FLAG
@ SCORE_ENEMY_FLAG

Divide::AI::WarSceneOrder::WarOrder::CAPTURE_ENEMY_FLAG
@ CAPTURE_ENEMY_FLAG

Divide::AI::WarSceneOrder::WarOrder::KILL_ENEMY
@ KILL_ENEMY

Divide::GUIDWrapper::getGUID
FORCE_INLINE I64 getGUID() const noexcept
Definition: GUIDWrapper.h:51

Divide::GUIMessageBox::MessageType::MESSAGE_WARNING
@ MESSAGE_WARNING

Divide::GUIMessageBox::MessageType::MESSAGE_INFO
@ MESSAGE_INFO

Divide::GUIMessageBox::setMessage
void setMessage(const string &message)
Definition: GUIMessageBox.cpp:68

Divide::GUIMessageBox::show
void show() noexcept
Definition: GUIMessageBox.h:66

Divide::GUIMessageBox::setTitle
void setTitle(const string &titleText)
Definition: GUIMessageBox.cpp:62

Divide::GUIMessageBox::setMessageType
void setMessageType(MessageType type)
Definition: GUIMessageBox.cpp:83

Divide::ITransform::translateX
void translateX(F32 positionX)
Translate the object on the X axis by the specified amount.
Definition: TransformInterface.inl:92

Divide::NPC
NPC base class. Every character in the game is an NPC by default except the Player.
Definition: NPC.h:46

Divide::NPC::getAIEntity
AI::AIEntity * getAIEntity() const noexcept
Definition: NPC.cpp:20

Divide::RigidBodyComponent
Definition: RigidBodyComponent.h:51

Divide::SceneGraphNode
Definition: SceneGraphNode.h:110

Divide::SceneGraphNode::handle
FORCE_INLINE SceneNodeHandle handle() const noexcept
Definition: SceneGraphNode.h:226

Divide::SceneGraphNode::setParent
void setParent(SceneGraphNode *parent, bool defer=false)
Changing a node's parent means removing this node from the current parent's child list and appending ...
Definition: SceneGraphNode.cpp:253

Divide::SceneGraphNode::addChildNode
SceneGraphNode * addChildNode(const SceneGraphNodeDescriptor &descriptor)
Add child node increments the node's ref counter if the node was already added to the scene graph.
Definition: SceneGraphNode.cpp:819

Divide::SceneGraphNode::get
FORCE_INLINE T * get() const
Returns a pointer to a specific component. Returns null if the SGN does not have the component reques...
Definition: SceneGraphNode.h:241

Divide::TransformComponent
Definition: TransformComponent.h:53

Divide::TransformComponent::setPosition
void setPosition(const vec3< F32 > &position) override
Component <-> Transform interface.
Definition: TransformComponent.cpp:137

Divide::TransformComponent::popTransforms
bool popTransforms()
Definition: TransformComponent.cpp:461

Divide::TransformComponent::rotateY
void rotateY(Angle::DEGREES< F32 > angle) override
Rotate on the Y axis (Axis-Angle used) by the specified angle (either degrees or radians)
Definition: TransformComponent.cpp:360

Divide::TransformComponent::setScale
void setScale(const vec3< F32 > &amount) override
Set the local X,Y and Z scale factors.
Definition: TransformComponent.cpp:152

Divide::TransformComponent::getWorldPosition
vec3< F32 > getWorldPosition() const
Return the position.
Definition: TransformComponent.cpp:676

Divide::UnitComponent
Definition: UnitComponent.h:41

Divide::UnitComponent::getUnit
std::shared_ptr< T > getUnit() const noexcept
Definition: UnitComponent.h:49

Divide::goap::Action::setPrecondition
void setPrecondition(const I32 key, const bool value)
Definition: Action.h:59

Divide::goap::Action::setEffect
void setEffect(const I32 key, const bool value)
Definition: Action.h:66

Divide::vec3
Definition: MathVectors.h:480

Divide::AI::GOAPValue
bool GOAPValue
Definition: GOAPInterface.h:46

Divide::AI::GOAPFact
I32 GOAPFact
Definition: GOAPInterface.h:45

Divide::AI::UnitAttributes::DAMAGE
@ DAMAGE

Divide::AI::UnitAttributes::ALIVE_FLAG
@ ALIVE_FLAG

Divide::AI::UnitAttributes::HEALTH_POINTS
@ HEALTH_POINTS

Divide::AI::SensorType::VISUAL_SENSOR
@ VISUAL_SENSOR

Divide::Angle::DEGREES
T DEGREES
Definition: MathHelper.h:275

Divide::Config::Build::IS_DEBUG_BUILD
constexpr bool IS_DEBUG_BUILD
Definition: config.h:55

Divide::Metric::Base
constexpr T Base(T a)
Base value.
Definition: MathHelper.inl:503

Divide::Time::App::ElapsedMicroseconds
U64 ElapsedMicroseconds() noexcept
Definition: ApplicationTimer.cpp:68

Divide::Time::SecondsToMicroseconds
constexpr T SecondsToMicroseconds(U a) noexcept
Definition: MathHelper.inl:767

Divide::Util::StringFormat
Str StringFormat(const char *fmt, Args &&...args)
Definition: StringHelper.inl:358

Divide::Util::to_string
string to_string(GET_PASS_TYPE< T > value)

Divide::anonymous_namespace{WarSceneAI.cpp}::g_navMeshStarted
bool g_navMeshStarted
Definition: WarSceneAI.cpp:22

Divide
Handle console commands that start with a forward slash.
Definition: AIProcessor.cpp:7

Divide::NodeUsageContext::NODE_DYNAMIC
@ NODE_DYNAMIC

Divide::to_U32
constexpr U32 to_U32(const T value)
Definition: PlatformDataTypes.h:262

Divide::_faction
AI::AITeam * _faction[2]
Teams are factions for AIEntites so they can manage friend/foe situations.
Definition: WarScene.h:100

Divide::_lastNavMeshBuildTime
U64 _lastNavMeshBuildTime
Definition: WarScene.h:92

Divide::_elapsedGameTime
U64 _elapsedGameTime
Definition: WarScene.h:88

Divide::IS_IN_RANGE_INCLUSIVE
bool IS_IN_RANGE_INCLUSIVE(const T x, const U min, const U max) noexcept
Definition: PlatformDefines.h:549

Divide::removeUnits
bool removeUnits()
Definition: WarSceneAI.cpp:160

Divide::I32
int32_t I32
Definition: PlatformDataTypes.h:50

Divide::U8
uint8_t U8
Definition: PlatformDataTypes.h:44

Divide::addUnits
bool addUnits()
Definition: WarSceneAI.cpp:176

Divide::_armyNPCs
vector< SceneGraphNode * > _armyNPCs[2]
NPC's are the actual game entities.
Definition: WarScene.h:94

Divide::ComponentType::SELECTION
@ SELECTION

Divide::ComponentType::RIGID_BODY
@ RIGID_BODY

Divide::ComponentType::RENDERING
@ RENDERING

Divide::ComponentType::BOUNDS
@ BOUNDS

Divide::ComponentType::NAVIGATION
@ NAVIGATION

Divide::ComponentType::NETWORKING
@ NETWORKING

Divide::ComponentType::TRANSFORM
@ TRANSFORM

Divide::ComponentType::UNIT
@ UNIT

Divide::Random
T Random()
Definition: MathHelper.inl:95

Divide::F32
float F32
Definition: PlatformDataTypes.h:82

Divide::_scoreLimit
U32 _scoreLimit
Definition: WarScene.h:86

Divide::U16
uint16_t U16
Definition: PlatformDataTypes.h:45

Divide::_runCount
U32 _runCount
Definition: WarScene.h:87

Divide::_flag
SceneGraphNode * _flag[2]
Definition: WarScene.h:96

Divide::_resetUnits
bool _resetUnits
Definition: WarScene.h:90

Divide::_timeLimitMinutes
U32 _timeLimitMinutes
Definition: WarScene.h:85

Divide::PhysicsGroup::GROUP_KINEMATIC
@ GROUP_KINEMATIC

Divide::_infoBox
GUIMessageBox * _infoBox
Definition: WarScene.h:81

Divide::checkGameCompletion
void checkGameCompletion()
Definition: WarSceneAI.cpp:45

Divide::I64
int64_t I64
Definition: PlatformDataTypes.h:51

Divide::U32
uint32_t U32
Definition: PlatformDataTypes.h:46

Divide::U64
uint64_t U64
Definition: PlatformDataTypes.h:47

Divide::to_base
constexpr auto to_base(const Type value) -> Type
Definition: PlatformDataTypes.h:228

Divide::AI::GOAPPackage
Definition: WarSceneAIProcessor.h:166

Divide::AI::GOAPPackage::_goalList
GOAPGoalList _goalList
Definition: WarSceneAIProcessor.h:168

Divide::AI::GOAPPackage::_actionSet
vector< WarSceneAction > _actionSet
Definition: WarSceneAIProcessor.h:169

Divide::Console::d_printfn
static NO_INLINE void d_printfn(const char *format, T &&... args)

Divide::SceneGraphNodeDescriptor
Definition: SceneGraphNode.h:85

Divide::SceneGraphNodeDescriptor::_serialize
bool _serialize
Definition: SceneGraphNode.h:92

Divide::SceneGraphNodeDescriptor::_nodeHandle
SceneNodeHandle _nodeHandle
Definition: SceneGraphNode.h:88

Divide::SceneGraphNodeDescriptor::_usageContext
NodeUsageContext _usageContext
Definition: SceneGraphNode.h:91

Divide::SceneGraphNodeDescriptor::_componentMask
U32 _componentMask
Definition: SceneGraphNode.h:89

Divide::SceneGraphNodeDescriptor::_name
Str< 64 > _name
Definition: SceneGraphNode.h:86

Divide::SceneNodeHandle
Definition: SceneGraphNode.h:71

Divide::goap::WorldState::setVariable
void setVariable(const int var_id, const bool value)
Definition: WorldState.cpp:15