Оптимизация, сжатие переменных

#include <QCoreApplication>
#include <QProcess>
#include "simpleorganism.h"
#include <iostream>
#include <time.h>
#include <QDebug>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    srand(time(NULL));
    SimpleOrganism::pull_organism.clear();
    for (int i = 0; i < 100; ++i)
        SimpleOrganism::pull_organism.push_back(new SimpleOrganism());
 
    for (int i = 0; i < 10000; ++i) {
        SimpleOrganism::global_life_cicle();
      //  if (i % 10 == 0) {
            SimpleOrganism::show_stat();
      //  }
 
 
    }
 
 
    return a.exec();
}

#ifndef DNA_H
#define DNA_H
 
#include <list>
 
#define G_DNA_SIZE 20
 
class DNA
{
 
public:
    explicit DNA();
    explicit DNA(DNA * parent_dna);
    ~DNA();
 
    //QList<short>  get_dna();
    //short get_dna();
    short get_dna_block(int i);
    bool set_dna_block(int i, short param);
    bool copy_dna(DNA * parent_dna);
    bool mutations(int i, unsigned int random);
    bool mutations(unsigned int random);
private:
    //QList<short> dna;
    short dna[G_DNA_SIZE];
 
};
 
#endif // DNA_H

#include "dna.h"
#include <QDebug>
 
 
DNA::DNA()
{
    for (int i = 0; i < G_DNA_SIZE; ++i) {
        dna[i] = rand() % 20 + 2;
    }
}
 
DNA::DNA(DNA *parent_dna)
{
    copy_dna(parent_dna);
}
 
DNA::~DNA() {
 
}
 
 
short DNA::get_dna_block(int i) {
    return dna[i];
}
 
bool DNA::set_dna_block(int i, short param) {
    if (i < 1)
        return false;
    dna[i] = param;
    return true;
}
 
bool DNA::copy_dna(DNA *parent_dna) {
    for (int i = 0; i < G_DNA_SIZE; i++)
        dna[i] = parent_dna->get_dna_block(i);
    return true;
}
 
bool DNA::mutations(int i, unsigned int random) {
    //int random = rand() % 100;
    if (random % 100 <= 49)
        dna[i]++;
    else
        if (dna[i] > 1)
            dna[i]--;
 
    return true;
}
 
bool DNA::mutations(unsigned int random) {
    for (unsigned int i = 0; i < random % (G_DNA_SIZE / 2) + 1; ++i)
      mutations(random % (G_DNA_SIZE - 1) + 1, random);
//    mutations(random % (G_DNA_SIZE - 1) + 1, random);
 
    return true;
}

#ifndef SIMPLEORGANISM_H
#define SIMPLEORGANISM_H
 
#include <QList>
#include <QListIterator>
#include <QLinkedList>
#include <QLinkedListIterator>
#include <QMutableListIterator>
#include <QDebug>
#include <QtMath>
 
 
#include <cmath>
#include <time.h>
#include <list>
#include <forward_list>
#include <iterator>
#include "dna.h"
 
 
#define LIFE_INTERVAL 0.1
 
struct statistic {
    int mutations;
    int alives;
    int deads;
    int creates;
    int delete_objects;
    int size_pull;
    int del_test;
 
};
 
class SimpleOrganism
{
 
public:
    static class Map map;
    static uint64_t GLOBAL_ID_ORGANISM;
    static uint64_t GLOBAL_CLASS_ORGANISM;
    //static QLinkedList<SimpleOrganism *> pull_organism;
    //static QLinkedList<SimpleOrganism *>::iterator g_itr;
    static std::list<SimpleOrganism *> pull_organism;
    static std::list<SimpleOrganism *>::iterator g_itr;
    static bool global_life_cicle();
    static void show_stat();
 
    explicit SimpleOrganism();
    explicit SimpleOrganism(SimpleOrganism *parent_organism);
    ~SimpleOrganism();
    DNA * dna;
    uint64_t get_id();
    uint64_t get_class();
 
    bool lifecicle();
    bool get_life();
    void clone();
    void death();
    void show();
    void delete_this();
 
    uint64_t * get_ID_point();
    double * get_posX_point();
    double * get_posY_point();
    SimpleOrganism * get_this_point();
private:
    uint64_t * ID_Organism;
    uint64_t * Class_organism;
    static statistic stat;
 
    struct parametrs {
        float outer_shell; //внешняя оболочка толщина   [1]
        float inner_shell; //внутреняя оболочка толщина [2]
        float insides;     //внутренности толщина       [3]
        float force;       //массивность/сила/etc. [4]
        float density;     //плотность             [5]
        float life_cicle;      //жизненный цыкл.      [8]
    } max_param, current_param;
 
    struct movement {
        float speed;
        float direction; //направление 360градусов
        float acceleration = 0; //разгон, макс 100% 1.0.
        double * posX;
        double * posY;
        bool move = false;
    } move;
 
    float size;        //общая толщина. (радиус)
    float hungry;      //голод
    bool life;
 
    bool dna_calc();
    bool param_calc();
    bool push_pull();
 
 
};
 
#endif // SIMPLEORGANISM_H

#include "simpleorganism.h"
#include "map.h"
#include <random>
 
#define MAX_SPEED current_param.force - ((size * (current_param.density / 10)) / 20)
 
uint64_t SimpleOrganism::GLOBAL_ID_ORGANISM = 0;
uint64_t SimpleOrganism::GLOBAL_CLASS_ORGANISM = 0;
statistic SimpleOrganism::stat;
Map SimpleOrganism::map;
 
 
 
//QList<SimpleOrganism *> SimpleOrganism::pull_organusm;
//QVector<SimpleOrganism *> SimpleOrganism::pull_organism;
//std::vector<SimpleOrganism *> SimpleOrganism::pull_organism;
//std::deque<SimpleOrganism *> SimpleOrganism::pull_organism;
//std::deque<SimpleOrganism *>::iterator SimpleOrganism::g_itr;
//QLinkedList<SimpleOrganism *> SimpleOrganism::pull_organism;
//QLinkedList<SimpleOrganism *>::iterator SimpleOrganism::g_itr;
 
std::list<SimpleOrganism *> SimpleOrganism::pull_organism;
std::list<SimpleOrganism *>::iterator SimpleOrganism::g_itr;
 
SimpleOrganism::SimpleOrganism()
{
    ID_Organism = new uint64_t;
    *ID_Organism = GLOBAL_ID_ORGANISM;
    GLOBAL_ID_ORGANISM++;
 
 
    Class_organism = new uint64_t;
    *Class_organism = GLOBAL_CLASS_ORGANISM;
    GLOBAL_CLASS_ORGANISM++;
 
    move.posX = new double;
    *move.posX = 0;
    move.posY = new double;
    *move.posY = 0;
 
   // this->setObjectName("Organism CLASS: " + QString().number(Class_organism) + "; ID: " + QString().number(GLOBAL_ID_ORGANISM));
 
    dna = new DNA();
    dna_calc();
 
}
 
SimpleOrganism::SimpleOrganism(SimpleOrganism *parent_organism)
{
    ID_Organism = new uint64_t;
    *ID_Organism = GLOBAL_ID_ORGANISM;
    GLOBAL_ID_ORGANISM++;
 
    Class_organism = new uint64_t;
    *Class_organism = parent_organism->get_class();
 
    move.posX = new double;
    *move.posX = 0;
    move.posY = new double;
    *move.posY = 0;
 
    dna = new DNA(parent_organism->dna);
    dna_calc();
}
 
SimpleOrganism::~SimpleOrganism() {
    delete ID_Organism;
    delete Class_organism;
    delete move.posX;
    delete move.posY;
    delete dna;
    stat.delete_objects++;
}
 
bool SimpleOrganism::dna_calc() {
    map.push(this);
    stat.alives++;
    stat.creates++;
 
    max_param.insides = log(dna->get_dna_block(3)) / log(1.01); //внутренности от ДНК
    max_param.outer_shell = max_param.insides / 20 + (log(dna->get_dna_block(1)) / log(1.1) / 2); //внешняя оболочка, зависит от размеров внутренностей и ДНК
    max_param.inner_shell = max_param.insides / 20 + (log(dna->get_dna_block(2)) / log(1.1) / 2); //внутренняя оболочка, зависит от размера внутренностей и ДНК
    max_param.force = log(dna->get_dna_block(4)) / log(1.01); //мощность.
    max_param.density = log(dna->get_dna_block(5)) / log(1.1); // чем выше плотность - тем прочнее и медленнее создание.
    max_param.life_cicle = log(dna->get_dna_block(8)) / log(1.1);
 
    current_param.life_cicle = LIFE_INTERVAL;
 
    life = true;
    hungry = 1;
    return true;
}
 
bool SimpleOrganism::param_calc() {
 
    float procent_life = current_param.life_cicle / max_param.life_cicle;
    current_param.insides = max_param.insides * procent_life;
    current_param.outer_shell = max_param.outer_shell  * procent_life;
    current_param.inner_shell = max_param.inner_shell * procent_life;
    current_param.force = max_param.force * procent_life;
    current_param.density = max_param.density * procent_life;
 
    size = current_param.insides + current_param.inner_shell + current_param.outer_shell;
    float temp_speed = current_param.force - ((size * (current_param.density / 10)) / 20);
    if (move.move) {
        if (move.acceleration < 1)
            move.acceleration += 0.1;
    }
    else {
        if (move.acceleration > 0)
            move.acceleration -= 0.1;
    }
    move.speed = temp_speed * move.acceleration;
 
    return true;
}
 
bool SimpleOrganism::lifecicle() {
    if (!life)
        return false;
 
    unsigned int r = rand();
    //смерть от голода.
    if (hungry >= 100) {
        death();
        return false;
    }
 
    //Вероятность смерти от старости
    if (current_param.life_cicle > max_param.life_cicle) {
        if (r % 100+1 <= current_param.life_cicle / max_param.life_cicle * 100 - 100) {
            death();
            return false;
        }
    }
 
    current_param.life_cicle += LIFE_INTERVAL;
 
    //Голод
    //if (hungry < 100)
   //     hungry++;
 
    if (r % 10000 <= 5) {
        dna->mutations(r);
        stat.mutations++;
    }
 
    if (current_param.life_cicle / max_param.life_cicle * 100 + (r % 40) - hungry >= 100 ) {
        clone();
        return false;
    }
 
    param_calc();
    return true;
}
 
bool SimpleOrganism::global_life_cicle() {
    clock_t start_timer = clock();
    //clock_t stop_timer;
    for (g_itr = pull_organism.begin(); g_itr != pull_organism.cend(); g_itr++) {
        (*g_itr)->lifecicle();
    }
    //Ограничитель FPS
   // while (clock() - start_timer < 100000) {}
 
    if (stat.deads > 200000) {
        map.clear();
        for (g_itr = pull_organism.begin(); g_itr != pull_organism.cend(); ++g_itr) {
            if (stat.deads < 100000)
                break;
            if (!(*g_itr)->get_life()) {
                stat.deads--;
                (*g_itr)->delete_this();
                pull_organism.erase(g_itr);
                g_itr--;
            }
        }
        stat.del_test = map.get_count();
    }
 
    return true;
}
 
 
void SimpleOrganism::death() {
    life = false;
    stat.deads++;
    stat.alives--;
}
 
void SimpleOrganism::clone() {
    pull_organism.push_back(new SimpleOrganism(this));
    pull_organism.push_back(new SimpleOrganism(this));
    death();
}
 
uint64_t SimpleOrganism::get_class() {
    return *Class_organism;
}
 
uint64_t SimpleOrganism::get_id() {
    return *ID_Organism;
}
 
bool SimpleOrganism::get_life() {
    return life;
}
 
bool SimpleOrganism::push_pull() {
    pull_organism.push_back(this);
    return true;
}
 
 
void SimpleOrganism::show_stat() {
    qDebug() << "\n####STATS:####"
             << "\n creates - " << stat.creates
             << "\n lifes - " << stat.alives
             << "\n deads - " << stat.deads
             << "\n mutations - " << stat.mutations
             << "\n delete obj - " << stat.delete_objects
             << "\n size_pull - " << stat.size_pull
             << "\n del test - " << stat.del_test
             << "\n#############\n";
}
 
void SimpleOrganism::show() {
    qDebug() << "life " << life
             << "\n life cicle " << current_param.life_cicle;
 
}
 
void SimpleOrganism::delete_this() {
    delete this;
}
 
 
uint64_t * SimpleOrganism::get_ID_point() {
    return ID_Organism;
}
 
double * SimpleOrganism::get_posX_point() {
    return move.posX;
}
 
double * SimpleOrganism::get_posY_point() {
    return move.posY;
}
 
SimpleOrganism * SimpleOrganism::get_this_point() {
    return this;
}

#ifndef MAP_H
#define MAP_H
#include <list>
#include <iterator>
 
struct coords {
    uint64_t * ID;
    double * posX;
    double * posY;
    class SimpleOrganism * object;
};
 
class Map
{
public:
    Map();
    ~Map();
 
    bool push(class SimpleOrganism * value);
    coords * get(uint64_t ID);
    coords * get(class SimpleOrganism *value);
    coords * get(double posX, double posY);
    int get_count();
    void clear();
 
private:
    std::list<coords *> map;
    std::list<coords *>::iterator itr;
};
 
#endif // MAP_H

#include "map.h"
#include "simpleorganism.h"
 
Map::Map() {
 
}
 
Map::~Map() {
    while (!map.empty())
        delete *(map.begin());
}
 
coords * Map::get(uint64_t ID) {
    for (itr = map.begin(); itr != map.cend(); ++itr)
        if (*(*itr)->ID == ID)
            return (*itr);
    return NULL;
}
 
coords * Map::get(SimpleOrganism * value) {
    for (itr = map.begin(); itr != map.cend(); ++itr)
        if ((*itr)->object == value)
            return (*itr);
    return NULL;
}
 
coords * Map::get(double posX, double posY) {
    for (itr = map.begin(); itr != map.cend(); ++itr)
        if (*(*itr)->posX == posX && *(*itr)->posY == posY)
            return (*itr);
    return NULL;
}
 
bool Map::push(SimpleOrganism * value) {
    map.push_back(new coords);
    map.back()->ID = value->get_ID_point();
    map.back()->posX = value->get_posX_point();
    map.back()->posY = value->get_posY_point();
    map.back()->object = value->get_this_point();
    return true;
}
 
int Map::get_count() {
    return map.size();
}
 
void Map::clear() {
    for (itr = map.begin(); itr != map.cend(); ++itr) {
        if (!(*itr)->object->get_life()) {
            map.erase(itr);
            --itr;
        }
    }
}

bool SimpleOrganism::dna_calc() {
    itr_map_this = map.push(this);
 
    stat.alives++;
    stat.creates++;
 
    max_param.insides = log(dna->get_dna_block(3)) / log(1.01); //внутренности от ДНК
    max_param.outer_shell = max_param.insides / 20 + (log(dna->get_dna_block(1)) / log(1.1) / 2); //внешняя оболочка, зависит от размеров внутренностей и ДНК
    max_param.inner_shell = max_param.insides / 20 + (log(dna->get_dna_block(2)) / log(1.1) / 2); //внутренняя оболочка, зависит от размера внутренностей и ДНК
    max_param.force = log(dna->get_dna_block(4)) / log(1.01); //мощность.
    max_param.density = log(dna->get_dna_block(5)) / log(1.1); // чем выше плотность - тем прочнее и медленнее создание.
    max_param.life_cicle = log(dna->get_dna_block(8)) / log(1.1);
 
    current_param.life_cicle = LIFE_INTERVAL;
 
    life = true;
    del = false;
    corpse = 0;
    hungry = 1;
    return true;
}

std::list<coords *>::iterator Map::push(SimpleOrganism * value) {
    map.push_back(new coords);
    map.back()->ID = value->ID_Organism;
    map.back()->posX = value->move.posX;
    map.back()->posY = value->move.posY;
    map.back()->object = value;
    return --map.end();
}

#ifndef MAP_H
#define MAP_H
#include <list>
#include <iterator>
 
#define MAX_LEVEL 20
#define SIZE_MAP 1000000000
#define MAX_OBJ 20
 
 
class Map
{
public:
    Map(Map * parent_ = 0, int level = 0, double X, double Y, double size_ = SIZE_MAP);
    ~Map();
 
    bool push(class SimpleOrganism * object);
    bool cicle();
private:
    //размер карты = центральная точка  (+size ко всем краям)
    double size;
    //глубина
    int level;
    //раздроблена ли?
    bool drop;
    //центр карты
    struct {
        double X = 0;
        double Y = 0;
    } point;
 
 
 
    std::list<class SimpleOrganism *> pull;
    Map * parent;
    Map * NW;
    Map * NE;
    Map * SW;
    Map * SE;
 
    friend class SimpleOrganism;
};
 
#endif // MAP_H

#include "map.h"
#include "simpleorganism.h"
 
Map::Map(Map *parent_, int level, double X, double Y, double size_) {
    drop = false;
    point.X = X;
    point.Y = Y;
    const double s = size * 0.5f;
    parent = parent_;
    size = size_;
    if (level == MAX_LEVEL)
        return;
    NW = new Map(this, level+1, X - s, Y + s, s);
    NE = new Map(this, level+1, X + s, Y + s, s);
    SW = new Map(this, level+1, X - s, Y - s, s);
    SE = new Map(this, level+1, X + s, Y - s, s);
}
 
Map::~Map() {
    if (level == MAX_LEVEL)
        return;
 
    delete NW;
    delete NE;
    delete SW;
    delete SE;
}
 
bool Map::push(SimpleOrganism *object) {
    if (pull.size() < MAX_OBJ && drop == false) {
        //если обьект уходит за пределы текущего куба - то передать его родителю.
        //защиты от ухода за предел MAX_SIZE пока нету
        if (object->move.posX > X + size && object->move.posY > Y + size)
            parent->push(object);
        else if (object->move.posX < X - size && object->move.posY > Y + size)
            parent->push(object);
        else if (object->move.posX > X + size && object->move.posY < Y - size)
            parent->push(object);
        else if (object->move.posX < X - size && object->move.posY < Y - size)
            parent->push(object);
        else
            pull.push_back(object);
            return true;
    } //если текущий обьект раздроблен или переполнен - передаем следующему по глубине обьекту
    else if (object->move.posX > X && object->move.posY > Y)
        NW->push(object);
    else if (object->move.posX <= X && object->move.posY > Y)
        NE->push(object);
    else if (object->move.posX > X && object->move.posY <= Y)
        SW->push(object);
    else if (object->move.posX <= X && object->move.posY <= Y)
        SE->push(object);
    else
        return false;
    drop = true;
    return true;
}
 
bool Map::cicle() {
    if (!pull.empty()) {
        //пересортировка обьектов
        if (drop == true)
            for (auto it = pull.begin(); it != pull.cend();) {
                push((*it));
                it = pull.erase(it);
            }
        else {
            for (auto it = pull.begin(); it != pull.cend(); ) {
                if (!(*it)->get_del()) {
                    (*it)->lifecicle();
                    if ((*it)->move.posX > X+size && (*it)->move.posY > Y+size) {
                        parent->push((*it));
                        it = pull.erase(it);
                    }
                    else if ((*it)->move.posX < X-size && (*it)->move.posY > Y+size) {
                        parent->push((*it));
                        it = pull.erase(it);
                    }
                    else if ((*it)->move.posX > X+size && (*it)->move.posY < Y-size) {
                        parent->push((*it));
                        it = pull.erase(it);
                    }
                    else if ((*it)->move.posX < X-size && (*it)->move.posY < Y-size) {
                        parent->push((*it));
                        it = pull.erase(it);
                    }
                    ++it;
                }
                else {
                    delete (*it);
                    (*it)->stat.deads--;
                    (*it)->stat.delete_objects++;
                    it = pull.erase(it);
                } //else {
            } //for(auto it = pull.begin(); it != pull.cend(); ) {
        } //else {
    } // if(!pull.empty()) {
    else if (level != MAX_LEVEL) {
        NW->cicle();
        NE->cicle();
        SW->cicle();
        SE->cicle();
    }
}

#ifndef VECTORMOVE_H
#define VECTORMOVE_H
 
struct vec {
    double X;
    double Y;
};
 
class VectorMove
{
public:
    VectorMove(double * X_, double * Y_, double * speed_);
    double* X;
    double* Y;
    double* speed;
    double step;
 
    vec Way;
 
 
    void new_vector(double X_, double Y_, double newspeed);
    void move();
    void normalize();
private:
 
};
 
#endif // VECTORMOVE_H

#include "vectormove.h"
#include <math.h>
 
VectorMove::VectorMove(double *X_, double *Y_, double *speed_)
{
    X = X_;
    Y = Y_;
    speed = speed_;
}
 
void VectorMove::move() {
    //делаем шаг
    X += vX * (1/step);
    Y += vY * (1/step);
 
}
 
void VectorMove::new_vector(double X_, double Y_) {
    vec.X = X_;
    vec.Y = Y_;
    //количество шагов до конечной точки
    step = abs((sqrt((vec.X*vec.X) + (vec.Y*vec.Y)) - sqrt((X*X) + (Y*Y))) / speed);
}