CommandMemberFocusState_8h_source.html

#ifndef ConscienceEnvironmentInteractionCommandMemberFocusState_h

#define ConscienceEnvironmentInteractionCommandMemberFocusState_h


#include "./Command.h"

#include "Unit/CscUnitOrigin.h"

#include "Unit/CscUnitType.h"

#include "Knowledge/CscKnowledgeItem.h"

#include "ArtificialIntelligence/CscEntityReflexion.h"

#include "Parser/CscCommandAutoParse.h"

#include <array>

using std::array;

using namespace conscience_core::knowledge;


namespace conscience_core::bridging::commands {


    class CSC_DLL_IMPORTEXPORT CommandMemberFocusState : public CscCommand {


    public:

        inline static const CommandTypeId COMMAND_ID = "MEMBER_FOCUS_STATE";


        CommandMemberFocusState(

            ptr<CscEntityReflexion> entityReflexion,


            int knowledgeId,

            const CscState *currentState,

            string membreToMove,

            FocusType focusType,

            float targetPositionX,

            float targetPositionY,

            float targetPositionZ,

            CscUnitType unitType,

            string targetOriginMember,

            bool symetrySearch,

            int nbStateMax,

            int deltaPerStateMax,

            bool optionCutLastestIfTheSameAndWorst,

            bool optionCutBeginingIfTheSame,

            bool optionDeltaPerStateMaxDegressive,

            float percentAvg,

            float percentMax,

            int stateDuration,

            int stateDelay,

            float solvedAt,

            array<bool, 4> outputTypes,

            CscArtificialIntelligenceTypes aiTypes);


        ~CommandMemberFocusState() {

            delete currentState;

        }


        int getKnowledgeId();

        const CscState *getCurrentState();

        string getMembreToMove();

        string getMembreRelative();

        float getTargetPositionX();

        float getTargetPositionY();

        float getTargetPositionZ();


        CscUnitType getUnitType();

        string getTargetOriginMember();


        bool getSymetrySearch();

        int getNbStateMax();

        int getDeltaPerStateMax();

        bool getOptionCutLastestIfTheSameAndWorst();

        bool getOptionCutBeginingIfTheSame();

        float getPercentAvg();

        float getPercentMax();

        float getSolvedAt();


    protected:

        const CscCommandExecutionResultSequence * doExecute(

            CscEnvironmentSimulator &environmentSimulator) override;

        ptr<CscEntityReflexion> getEntityReflexion() const override {

            return entityReflexion;

        }

    private:


        ptr<CscEntityReflexion> entityReflexion;


        const int knowledgeId;

        const CscState *const currentState;

        const string membreToMove;

        const float targetPositionX;

        const float targetPositionY;

        const float targetPositionZ;


        const CscUnitType unitType;

        const string targetOriginMember;


        const bool symetrySearch;

        const int nbStateMax;

        const int deltaPerStateMax;

        const bool optionCutLastestIfTheSameAndWorst;

        const bool optionCutBeginingIfTheSame;

        bool optionDeltaPerStateMaxDegressive;

        const float percentAvg;

        const float percentMax;

        const float solvedAt;

        const FocusType focusType;


        int stateDuration;

        int stateDelay;


        bool outputTypes[4];

        CscArtificialIntelligenceTypes aiTypes;

    };


COMMAND_REGISTER(CommandMemberFocusState,

            ptr<CscEntityReflexion>,

            int,

            const CscState *,

            string,

            FocusType,

            float,

            float,

            float,

            CscUnitType,

            string,

            bool,

            int,

            int,

            bool,

            bool,

            bool,

            float,

            float,

            int,

            int,

            float,

            array<bool, 4>,

            CscArtificialIntelligenceTypes)

}


#endif