CommandMemberToStateFromMemberTrigo.h

Go to the documentation of this file.

#ifndef ConscienceEnvironmentInteractionCommandMemberToStateFromMemberTrigo_h
#define ConscienceEnvironmentInteractionCommandMemberToStateFromMemberTrigo_h
 
#include "./Command.h"
#include "Unit/CscUnitOrigin.h"
#include "Unit/CscUnitType.h"
#include "Knowledge/CscKnowledgeItem.h"
#include "Parser/CscCommandAutoParse.h"
 
#include <array>
using std::array;
 
using namespace conscience_core::knowledge;
 
namespace conscience_core::bridging::commands {
 
    class CSC_DLL_IMPORTEXPORT CommandMemberToStateFromMemberTrigo : public CscCommand {
 
    public:
        inline static const string COMMAND_ID = "MEMBER_TO_STATE_FROM_MEMBER_TRIGO";
 
        CommandMemberToStateFromMemberTrigo(
            ptr<CscEntityReflexion> entityReflexion,
            int knowledgeId,
            const CscState *currentState,
            const string &membreToMove,
            const string &membreRelative,
            float targetPositionX,
            float targetPositionY,
            float targetPositionZ,
            float targetPositionXPonderation,
            float targetPositionYPonderation,
            float targetPositionZPonderation,
            float targetEulerX,
            float targetEulerY,
            float targetEulerZ,
            float targetEulerXPonderation,
            float targetEulerYPonderation,
            float targetEulerZPonderation,
            float targetAccX,
            float targetAccY,
            float targetAccZ,
            float targetAccXPonderation,
            float targetAccYPonderation,
            float targetAccZPonderation,
            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,
            float processAt,
            const array<bool, 4> & outputTypes,
            CscArtificialIntelligenceTypes aiTypes);
 
        int getKnowledgeId();
        const CscState *getCurrentState();
        string getMembreToMove();
        string getMembreRelative();
        float getTargetPositionX();
        float getTargetPositionY();
        float getTargetPositionZ();
        float getTargetEulerX();
        float getTargetEulerY();
        float getTargetEulerZ();
        CscUnitType getUnitType();
        string getTargetOriginMember();
 
    protected:
        ptr<CscEntityReflexion> getEntityReflexion() const override {
            return entityReflexion;
        }
        
        const CscCommandExecutionResultSequence * doExecute(
            CscEnvironmentSimulator &environmentSimulator) override;
 
    private:
 
        ptr<CscEntityReflexion> entityReflexion;
 
        const int knowledgeId;
        const CscState *const currentState;
        const string membreToMove;
        const string membreRelative;
        const float targetPositionX;
        const float targetPositionY;
        const float targetPositionZ;
        const float targetPositionXPonderation;
        const float targetPositionYPonderation;
        const float targetPositionZPonderation;
        const float targetEulerX;
        const float targetEulerY;
        const float targetEulerZ;
        const float targetEulerXPonderation;
        const float targetEulerYPonderation;
        const float targetEulerZPonderation;
        const float targetAccX;
        const float targetAccY;
        const float targetAccZ;
        const float targetAccXPonderation;
        const float targetAccYPonderation;
        const float targetAccZPonderation;
        
        const CscUnitType unitType;
        const string targetOriginMember;
 
        const bool symetrySearch;
        const int nbStateMax;
        const int deltaPerStateMax;
        const bool optionCutLastestIfTheSameAndWorst;
        const bool optionCutBeginingIfTheSame;
        const bool optionDeltaPerStateMaxDegressive;
        const float percentAvg;
        const float percentMax;
        const int stateDuration;
        const int stateDelay;
        const float solvedAt;
        const float processAt;
        
        bool outputTypes[4];
        
        CscArtificialIntelligenceTypes aiTypes;
    };
 
COMMAND_REGISTER(CommandMemberToStateFromMemberTrigo,
            ptr<CscEntityReflexion>,
            int,
            const CscState *,
            const string &,
            const string &,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            CscUnitType,
            string,
            bool,
            int,
            int,
            bool,
            bool,
            bool,
            float,
            float,
            int,
            int,
            float,
            float,
            const array<bool, 4> &,
            CscArtificialIntelligenceTypes)
}
 
#endif