CscObjectiveAi_8h_source.html

/*

 * CscObjectiveAi.h

 *

 *  Created on: 31 mai 2014

 *      Author: ilieszaoui

 */


#ifndef CSCOBJECTIVEAI_H_

#define CSCOBJECTIVEAI_H_


#include "ArtificialIntelligence/CscStrategyType.h"

#include "CoreObjects/CscEntityModel.h"

#include "CscCommon.h"

#include "CscGeneration.h"

#include "CscJacobianInverseKinematic.h"

#include "Knowledge/CscKnowledgeItem.h"

#include "Knowledge/CscKnowledgeItemTarget.h"

#include "Knowledge/CscKnowledgeItemTargetArmToPosition.h"

#include "Knowledge/CscKnowledgeItemTargetMemberToState.h"

#include "Knowledge/CscKnowledgeItemTargetMemberToStateFromMember.h"

#include "Simulator/CscEnvironmentSimulator.h"


using namespace conscience_core::knowledge;


class CSC_DLL_IMPORTEXPORT CscObjectiveAi {

public:

    CscObjectiveAi(const CscWorldEntity *entity, int idIn, CscState *stateIn, CscKnowledgeItemTarget *knowledgeItemIn, int personByGenerationMaxIn, CscWorldPlace *placeModelIn);

    void nextStep();

    CscPerson *getBestPerson();

    int countGenerations();

    int countTotalPersons();

    bool isSolved();

    bool validateCurrentSolution();

    CscPerson *generatePerson(CscKnowledgeItemTarget *knoItem, CscState *initialState);

    int getUsageCount();

    void incrementUsageCount();

    CscSequence *getResult();

    void changeIKTarget(vector<CscJacobianInverseKinematic::TargetIKParams *> targets);


    CscState *getInitialState();

    string toString();


    int getId() const;

    CscWorldElementId getEntityId();

    int getKnowledgeItemId() const;

    int getValidationCount() const;


    CscEnvironmentSimulator *getEnvironment() const;

    int getLastUsageTimeInt() const;

    time_t lastUsageTime = 0;

    float getEstimatedDuration();

    CscKnowledgeItem *getKnowledgeItem() const;

    virtual ~CscObjectiveAi();

    bool getDeployableToGlobalSimulator();

    int counterIteration = 0;

    CscState *getLastSolutionFound();


private:

    const CscWorldEntity *entity;


    int id;

    CscEnvironmentSimulator *environment;

    CscKnowledgeItemTarget *knowledgeItem;

    CscState *initialState;

    CscState *lastSolutionFound;

    CscGeneration *currentGeneration;

    CscGeneration *previousGeneration;

    CscPerson *bestPerson;

    bool solved;

    int personByGenerationMax;

    int maxSequenceSize;

    int currentGenerationId;

    int currentPersonId;

    int validationCount;

    int usageCount;

    float objectiveLimit;


    bool initialStateReached;


    vector<string> *names;

    vector<string> *namesWheels;

    void initJointsNames();

    void initWheelsNames();

    vector<float> *getDeltasBetweenValues(map<int, int> initialState, map<int, int> compareState);

    float defaultStateDelay = 200.0;

    float defaultStateDuration = 200.0; // 5 actions per second for genetic

    bool validateKinematicSolution();

    bool validateGeneticSolution();

    void moveToInitialState();

    bool isAIMemberPivotStationary(const string &memberName, float acceptedDelta);


    bool deployableToGlobalSimulator;


    /*

     Allow to block or limit outputs, if knowledge used has outputs which must be immobile or limited

     Complete pivotsCanMoveValues, propellersCanMoveValues and wheelsCanMoveValues in CscKnowledgeItem

     */

    void limitOutputs();


    /*

     Return the outputName which precise the two members linked by this output (ex: Core_HipLeft)

     */

    string outputName(const vector<const CscMember *> *members, int memberA, int memberB);


    /*

     Cut sequence of personToAdd where the mean of speed is smaller among states can become bestPerson

     and replay the sequence in realTime

     */

    void cutSequenceAndTryAgain(CscPerson *personToAdd);

};


#endif /* CSCOBJECTIVEAI_H_ */