dna.h

Go to the documentation of this file.

/* ========================================================================= */
/* ------------------------------------------------------------------------- *//*


 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Please read COPYING and README files in root folder
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
#ifndef __DNA_INC__
#define __DNA_INC__
//
//
//
//
/*  INCLUDES    ------------------------------------------------------------ */

#include    <april/april.h>
#include    <april/logic/uniqueid.h>
#include    <april/logic/dnaview.h>

#include    <QSettings>
#include    <QVector>

/*  INCLUDES    ============================================================ */
//
//
//
//
/*  DEFINITIONS    --------------------------------------------------------- */

namespace   april    {

class World;
class Factory;

/*  DEFINITIONS    ========================================================= */
//
//
//
//
/*  CLASS    --------------------------------------------------------------- */

class
        APRILSHARED_EXPORT
        DNA             {
    
    //
    //
    //
    //
    /*  DEFINITIONS    ----------------------------------------------------- */
    
    friend class DNAView;
    friend class ActorFactory;
    
public:
    
    
    struct  Partition   {
        
        ID          id_;
        
        int         start_;
        
        int         count_;
        
        
        bool            operator ==     ( const Partition & other ) const
        {
            return ( ( id_ == other.id_ ) && 
                     ( start_ == other.start_ ) && 
                     ( count_ == other.count_ ) );
        }
        bool            operator !=     ( const Partition & other ) const
        {
            return !operator==(other); 
        }
    };
    
public:
    
    struct  InitData    {
        ID          kind_;  
        quint64     cost_;  
        quint64     age_;   
        quint64     energy_;
    };
    
public:
    
    enum    Predef  {
        OffKind = 0,    
        OffBrains,      
        OffActuators,   
        OffSensors,     
        OffReflexes,    
        OffCost,        
        OffAge,         
        OffStartEnergy, 
        OffMax,
        OffLastList = OffReflexes+1
        /* the list of brains, actuators, sensors, reflex id's follows */
    };
    
    /*  DEFINITIONS    ===================================================== */
    //
    //
    //
    //
    /*  DATA    ------------------------------------------------------------ */
    
protected:
    
    QVector<Partition>          parts_;
    
    QList<qreal>                values_;
    
    QList<quint64>              values_i_;
    
    
    /*  DATA    ============================================================ */
    //
    //
    //
    //
    /*  FUNCTIONS    ------------------------------------------------------- */
    
public:
    
    
    DNA             ( void );
    
    DNA             ( const World * w, ID kind );
    
    ~DNA            ( void );
    

    bool            fromMerge       (
            const DNA &         p1,
            const DNA &         p2
            );
    
    bool            isValid         ( void ) const;
    
    bool            operator ==     ( const DNA & other ) const;
    
    
    
    /* OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO */

    
    

    DNAView         getView         ( ID id, Factory * f = NULL );
    

    DNAView         getView         ( ID id, int sz, Factory * f = NULL );
    
    ID              kind            ( void ) const;
    
    quint64         cost            ( void ) const
    { 
        Q_ASSERT(values_i_.length() >= OffMax ); 
        return values_i_.at( OffCost ); 
    }
    
    quint64         age             ( void ) const
    {
        Q_ASSERT(values_i_.length() >= OffMax ); 
        return values_i_.at( OffAge ); 
    }
    
    quint64         energy          ( void ) const
    { 
        Q_ASSERT(values_i_.length() >= OffMax ); 
        return values_i_.at( OffStartEnergy );
    }
    
    QList<ID>       brains          ( void ) const;
    
    QList<ID>       actuators       ( void ) const;
    
    QList<ID>       sensors         ( void ) const;
    
    QList<ID>       reflexes        ( void ) const;
    
    QVector<Partition>  partitions  ( void ) const
    { return parts_; }

    /* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo */
    
    
    /* OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO */

    

    bool            addBrain        ( ID id );
    

    bool            addActuator     ( ID id );
    

    bool            addSensor       ( ID id );
    

    bool            addReflex       ( ID id );
    
    
    /* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo */
    
    
    
    bool            save            ( QSettings & stg ) const;
    
    bool            load            ( QSettings & stg );
    
    
    static qreal    dnaNoise        ( void );
    
    
    int             findID          ( ID id ) const;
    

    void            initDNA         ( const InitData & init );
    

    void            reinitDNA       ( const DNA & src, bool clear_content );

    
    /* OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO */

    
private:
    
    bool            mergeAllVals    (
            const DNA &         p1,
            const DNA &         p2
            );
    
    int             mergeUniteEl    (
            int                 iter_1,
            int                 iter_2,
            int                 i_max_1,
            int                 i_max_2,
            const DNA &         p1,
            const DNA &         p2
            );
    
    bool            mergeBrains     (
            const DNA &         p1,
            const DNA &         p2
            );
    
    void            mergeAllParts   (
            const DNA &         p1,
            const DNA &         p2
            );
    
    void            mergeParts      (
            const Partition &   part_1, 
            const Partition &   part_2, 
            const DNA &         p1, 
            const DNA &         p2
            );
    
    void            mergePart       (
            const Partition &   part,
            const DNA &         p
            );
    
    
    /* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo */
    
    
#ifdef APRIL_INTERNAL_TESTS
public:
    void            setParts                ( QVector<Partition> & new_val )
    { parts_ = new_val; }
    void            setValues               ( QList<qreal> & new_val )
    { values_ = new_val; }
    void            setValuesI              ( QList<quint64> & new_val )
    { values_i_ = new_val; }
#endif
    
private:
    
    bool            getViewNotFound         (
            DNAView &           view,
            ID                  id,
            Factory *           f
            );
    
    
    /*  FUNCTIONS    ======================================================= */
    //
    //
    //
    //
    
};  /*  class DNA   */

/*  CLASS    =============================================================== */
//
//
//
//

}   //  namespace   april

#endif // __DNA_INC__
/* ------------------------------------------------------------------------- */
/* ========================================================================= */