CscKnowledgeItemTargetMemberToStateFromMember.h

Go to the documentation of this file.

//
//  CscKnowledgeItemTargetMemberToStateFromMember.hpp
//  ConscienceRobotManager
//
//  Created by Iliès Zaoui on 09/02/2019.
//  Copyright © 2019 IliesZaoui. All rights reserved.
//
 
#ifndef CscKnowledgeItemTargetMemberToStateFromMember_h
#define CscKnowledgeItemTargetMemberToStateFromMember_h
 
#include "Knowledge/CscKnowledgeItemTarget.h"
 
namespace conscience_core::knowledge {
 
    class CSC_DLL_IMPORTEXPORT CscKnowledgeItemTargetMemberToStateFromMember : public CscKnowledgeItemTarget {
    public:
        CscKnowledgeItemTargetMemberToStateFromMember(int knoItemId,
                                                      string itemName,
                                                      string memberBaseNameIn,
                                                      string memberTargetNameIn,
                                                      const vector<const TargetMemberValues *> *inputsTargetValuesIn,
                                                      const vector<const TargetMemberPonderation *> *inputsTargetPercentsIn,
                                                      CscUnitType unitTypeIn,
                                                      bool symemtrySearch,
                                                      int nbStateMax, int deltaPerStateMax,
                                                      bool optionCutLastestIfTheSameAndWorst,
                                                      bool optionCutBeginingIfTheSame,
                                                      bool optionDeltaPerStateMaxDegressive,
                                                      float percentAvg,
                                                      float percentMax,
                                                      int stateDuration,
                                                      int stateDelay,
                                                      float solvedAt,
                                                      bool outputTypes[],
                                                      CscArtificialIntelligenceTypes aiTypes,
                                                      bool playEvenNotSolved);
 
        string memberBaseName;
        string memberTargetName;
        bool playEvenNotSolved;
        bool isStatesSupportOf(CscState *state1, CscState *state2) override;
        bool isObjectiveSupportOf(CscKnowledgeItem *knowledgeItem) override;
        float evaluateState(CscState *stateIn, const CscWorldEntity *entity, CscState *initialState) override;
 
        CscPerson *generatePerson(CscEnvironmentSimulator *environment, const CscWorldEntity *entity, CscState *initialState, int personId, int generationId, CscGeneration *currentGeneration, CscGeneration *previousGeneration) override;
        CscPerson *generatePersonGenetic(CscEnvironmentSimulator *environment, const CscWorldEntity *entity, CscState *initialState, int personId, int generationId, CscGeneration *currentGeneration, CscGeneration *previousGeneration);
        CscPerson *generatePersonKinematic(CscEnvironmentSimulator *environment, const CscWorldEntity *entity, CscState *initialState, int personId, int generationId, CscGeneration *currentGeneration, CscGeneration *previousGeneration);
 
        map<CscStrategyType, float> strategyElitism;
        map<CscStrategyType, float> strategyProbability;
 
        static CscKnowledgeItemTargetMemberToStateFromMember *create(int targetId, string targetName,
                                                                     string baseMemberName, string targetMemberName,
                                                                     float posX, float posY, float posZ,
                                                                     float posPondX, float posPondY, float posPondZ,
                                                                     float pitch, float yaw, float roll,
                                                                     float pitchPond, float yawPond, float rollPond,
                                                                     float accX, float accY, float accZ,
                                                                     float accPondX, float accPondY, float accPondZ,
                                                                     CscUnitType unitType,
                                                                     bool symemtrySearch,
                                                                     int nbStateMax, int deltaPerStateMax,
                                                                     bool optionCutLastestIfTheSameAndWorst,
                                                                     bool optionCutBeginingIfTheSame,
                                                                     bool optionDeltaPerStateMaxDegressive,
                                                                     float percentAvg,
                                                                     float percentMax,
                                                                     int stateDuration,
                                                                     int stateDelay,
                                                                     float solvedAt,
                                                                     bool outputTypes[4],
                                                                     CscArtificialIntelligenceTypes aiTypes,
                                                                     float processAt) {
            auto inputsTargetValues = new vector<const TargetMemberValues *>();
            auto inputsTargetPercents = new vector<const TargetMemberPonderation *>();
 
            // State objective
            CscMemberInputStatus *inputsFinalCore = new CscMemberInputStatus(targetMemberName);
            TargetMemberValues *targetMemberValues = new TargetMemberValues();
            map<CscInputType, float> inputsTargetValuesCore;
            inputsTargetValuesCore[POS_X] = posX;
            inputsTargetValuesCore[POS_Y] = posY;
            inputsTargetValuesCore[POS_Z] = posZ;
            inputsTargetValuesCore[PITCH] = pitch;
            inputsTargetValuesCore[YAW] = yaw;
            inputsTargetValuesCore[ROLL] = roll;
            inputsTargetValuesCore[ACC_X] = accX;
            inputsTargetValuesCore[ACC_Y] = accY;
            inputsTargetValuesCore[ACC_Z] = accZ;
            inputsFinalCore->values = inputsTargetValuesCore;
            targetMemberValues->memberValues = inputsFinalCore;
            inputsTargetValues->push_back(targetMemberValues);
 
            // State Percents
            CscMemberInputPonderation *percentsFInalCore = new CscMemberInputPonderation(targetMemberName);
            TargetMemberPonderation *targetMemberPonderation = new TargetMemberPonderation();
            map<CscInputType, float> inputsTargetPercentsCore;
            inputsTargetPercentsCore[POS_X] = posPondX;
            inputsTargetPercentsCore[POS_Y] = posPondY;
            inputsTargetPercentsCore[POS_Z] = posPondZ;
            inputsTargetPercentsCore[PITCH] = pitchPond;
            inputsTargetPercentsCore[YAW] = yawPond;
            inputsTargetPercentsCore[ROLL] = rollPond;
            inputsTargetPercentsCore[ACC_X] = accPondX;
            inputsTargetPercentsCore[ACC_Y] = accPondY;
            inputsTargetPercentsCore[ACC_Z] = accPondZ;
            percentsFInalCore->values = inputsTargetPercentsCore;
            targetMemberPonderation->memberValues = percentsFInalCore;
            inputsTargetPercents->push_back(targetMemberPonderation);
 
            return new CscKnowledgeItemTargetMemberToStateFromMember(targetId, targetName,
                                                                     baseMemberName, targetMemberName,
                                                                     inputsTargetValues, inputsTargetPercents,
                                                                     unitType, symemtrySearch,
                                                                     nbStateMax, deltaPerStateMax,
                                                                     optionCutLastestIfTheSameAndWorst,
                                                                     optionCutBeginingIfTheSame,
                                                                     optionDeltaPerStateMaxDegressive,
                                                                     percentAvg,
                                                                     percentMax,
                                                                     stateDuration,
                                                                     stateDelay,
                                                                     solvedAt,
                                                                     outputTypes,
                                                                     aiTypes,
                                                                     processAt);
        }
    };
 
}
 
#endif /* CscKnowledgeItemTargetMemberToStateFromMember_h */