[C++] Klasy i zmienne statyczne +SFML

[gabrysb1995]

Mam następujący problem z kodem

Ukryta treść:    

Kod: Zaznacz cały

#include <SFML/Graphics.hpp>

using namespace sf;

const int rozmiarOknaX=1200;
const int rozmiarOknaY=800;
const int rozmiarTablica=2500;
const float dzielnikPredkosc=2000000;
const Vector2f prostokatPoczatek(400,400);
const Vector2f prostokatRozmiar(400,200);
const int liczbaPrzeszkodStala=1;


class mucha;

class przeszkody
{
    friend mucha;
private:
    int liczbaPrzeszkod=liczbaPrzeszkodStala;
    RectangleShape listaPrzeszkod[liczbaPrzeszkodStala];
public:
    przeszkody();
    RectangleShape* wyslijTablice ();
    int wyslijLiczbaprzeszod();
    RectangleShape wyslijNtaPrzeszkode(int);
};

class mucha : public CircleShape
{
private:
    int licznik=0;
    Vector2f polozenie;
    Vector2f predkosc;
    Vector2f tablicaPredkosc[rozmiarTablica];
    bool czyZyje;

public:
    przeszkody wszystkiePrzeszkody;   //ma byc static
    mucha();
    void aktualizuj();
    friend bool czyKolizja(RectangleShape przeszkody[], int liczbaprzeszkod, Vector2f polozenie);
};

int przeszkody::wyslijLiczbaprzeszod()
{
    return liczbaPrzeszkod;
}

RectangleShape przeszkody::wyslijNtaPrzeszkode(int n)
{
    return listaPrzeszkod[n];
}

przeszkody::przeszkody()
{
    for(int i=0; i<liczbaPrzeszkod;i++)
    {
        listaPrzeszkod[i].setSize(prostokatRozmiar);
        listaPrzeszkod[i].setPosition(prostokatPoczatek);
    }

}

RectangleShape* przeszkody::wyslijTablice()
{
    return listaPrzeszkod;
}

bool czyKolizja(RectangleShape* przeszkody, int liczbaPrzeszkod, Vector2f polozenie)
{
    for(int i=0; i<liczbaPrzeszkod; i++)
    {
        if(polozenie.x>przeszkody[i].getPosition().x&&
           polozenie.x<przeszkody[i].getPosition().x+przeszkody[i].getSize().x&&
           polozenie.y>przeszkody[i].getPosition().y&&
           polozenie.y<przeszkody[i].getPosition().y+przeszkody[i].getSize().y)
            return false;
    }
    return true;
}
mucha::mucha():polozenie(rozmiarOknaX/2,100), predkosc(0,0.25), czyZyje(true)
{
   for(int i=0; i<rozmiarTablica; i++)
   {
   tablicaPredkosc[i].x=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;             //zastapic funkcja losuj
   tablicaPredkosc[i].y=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;
   }
   setRadius(5);
   setOrigin(2.5, 2.5);
   setPosition(polozenie);

}

void mucha::aktualizuj()
{
    if(licznik<rozmiarTablica&&czyZyje)
    {
    setPosition(polozenie+=predkosc);               //zmienia polozenie a potem wysyla do funkcji setPosition
    predkosc+=tablicaPredkosc[licznik];
    }
    czyZyje=czyKolizja(wszystkiePrzeszkody.wyslijTablice(), wszystkiePrzeszkody.liczbaPrzeszkod, polozenie);

    licznik++;

}


int main()
{
    srand( time( NULL ) );
    RenderWindow okno(VideoMode(rozmiarOknaX, rozmiarOknaY), "SFML window");
    mucha mucha1;
    while (okno.isOpen())
    {
        Event event;
        while (okno.pollEvent(event))
        {
            if (event.type == Event::Closed)
                okno.close();
        }
        okno.clear();

        okno.draw(mucha1);
        for(int i=0; i<mucha1.wszystkiePrzeszkody.wyslijLiczbaprzeszod(); i++)
            okno.draw(mucha1.wszystkiePrzeszkody.wyslijNtaPrzeszkode(i));

        // Update the window
        okno.display();
        mucha1.aktualizuj();
    }

    return EXIT_SUCCESS;
}

, mniej więcej w nim chodzi o to, żeby pokazać zastosowanie algorytmu genetycznego na podstawie much, które próbują dolecieć do celu, omijając po drodze przeszkody, do zobrazowania tego użyłem SFML, lecz nie w tej bibliotece robi problem.

Jest funkcja zaprzyjaźniona czyKolizja która po prostu sprawdza czy mucha nie uderzyła w przeszkodę. Jest ona wywoływana przez metodę klasy Mucha, aktualizuj. Żeby tą funkcję wywołać z jednym z argumentów listaprzeszkód musiałem umieścić egzemplarz w klasie mucha. Jednak nie chcę, żeby każdy egzemplarz klasy mucha tworzył nowy identyczny egzemplarz klasy przeszkody, więc chciałem ten egzemplarz przeszkody w klasie mucha oznaczyć jaki static. Jednak wtedy wyskakują mi błędy, gdy chcę się odwołać do niego.

Dziękuję za jakąkolwiek pomoc, gdyż z tym problemem siedzę 2 dni i nie mam pomysłu jak go rozwiązać.

Edit. Jakby ktos znał lepsze rozwiązanie mojego problemu to też bym prosił o jakieś wskazówki:)

[lukequaint]

Robisz składową static i inicjalizujesz poza klasą:

Kod: Zaznacz cały

przeszkody mucha::wszystkiePrzeszkody = przeszkody();

To dość powszechny problem, powinieneś poszukać trochę w Sieci - na pewno byś znalazł .

Ze wskazówkami jest tak, że w końcu za bardzo poprawiony przez kogoś kod umyka naszemu zrozumieniu . Kilka rzeczy można by tu usprawnić, np.:

• utworzyć klasę Okno czy UkladWspolrzednych, która "zaopiekuje" się tymi wszystkimi zmiennymi globalnymi
• unikałbym przyjaźni - po to mamy składowe prywatne, by nikt obcy ich nie dotykał; położenie można udostępnić publiczną metodą
• wszystkiePrzeszkody lepiej byłoby przenieść do osobnej klasy (wtedy zmienna statyczna nie byłaby potrzebna) - żadna mucha nie przenosi ze sobą przeszkód
• wydaje mi się, że rozsądniej byłoby utworzyć klasę abstrakcyjną Obiekt i sprawdzać kolizje między obiektami tej klasy (po niej dziedziczyłaby i klasa Mucha, i klasa Przeszkoda); nie chcę się mądrować, bo mało wiem na temat samych kolizji - poszukaj jakiegoś tutoriala, gdzie jest to zrobione dobrze
• wyslijNtaPrzeszkode można by zamienić na przeciążony operator[]

.

[gabrysb1995]

Znowu mi ratujesz z ciężkiej sytuacji:) Dzięki wielkie.

Jest mi strasznie wstyd, że taka głupia drobnostka mi umknęła.

Co do zmiennych globalnych to są one chwilowe, służą mi do testowania kodu czy działa, potem się ich pozbędę(na pewno część )

Co do przyjaźni masz rację, mam niestety dziwny nawyk nadużywania przyjaźni.

Co do kolizji i klasy abstrakcyjnej to pomyślę, jak to zrobić, dzięki za sugestię.

Co do operatora[] fajna rzecz, kod będzie czytelniejszy

[lukequaint]

Z kolizjami to wszystko zależy od tego, co będzie "latać". Jeśli będziesz mieć jeden (ewentualnie dla więcej niż jednego można zrobić jakąś klasę bazową dla klas mucha i przeszkoda jak wyżej, by uwzględniać też inne obiekty klasy mucha) obiekt klasy mucha, najrozsądniej chyba będzie dodać do tej klasy (zamiast zaprzyjaźniać funkcję z zewnątrz) metodę:

Kod: Zaznacz cały

bool czyKolizja(const przeszkoda& p);

która dla będzie sprawdzała, czy ten obiekt koliduje z podaną przeszkodą.

Korzystając z range-based for można by Twój kod w kilku miejscach uprościć, ale tym pewnie zajmiejsz się na końcu.

Powodzenia .

[gabrysb1995]

Dzięki za kolejne rady,nie wiem jak Ci się odwdzięczę, powinienem móc klikać za każdą Twoją odpowiedź z 5 razy pomógł nie wiem czy aż tak bym rozwijał ten programik, bo w sumie ma tylko demonstrować algorytm genetyczny, oczyszczę kod na pewno, ale chyba klasy bazowej dla much i przeszkód nie będę robił, choć przy kolejnym programem z SFLM na pewno zacznę od pisania klasy bazowej I o range-based for słyszałem, ale weszła ta pętla w C11 i odruchowo piszę zwykłego fora

Ukryta treść:    

Kod: Zaznacz cały

#include <SFML/Graphics.hpp>
#include <cmath>
#include <algorithm>
#include <cassert>

using namespace sf;
using namespace std;

const int rozmiarOknaX=1200;
const int rozmiarOknaY=800;
const int rozmiarTablica=2500;
const float dzielnikPredkosc=2000000;
const Vector2f prostokatPoczatek(400,400);
const Vector2f prostokatRozmiar(400,200);
const int liczbaPrzeszkodStala=1;
const int liczbaMuch=500;
const int liczbaTur=100;
const Vector2f polozeniePoczatkowe(rozmiarOknaX/2,100);
const Vector2f predkoscPoczatkowa(0,0.25);
const Vector2f polozenieCelu(rozmiarOknaX/2, rozmiarOknaY-100);
const float promien=5;
const int dzielnikMutacji=100;
const int iloscKrzyzowan=liczbaMuch/10;

Color KolorPrzeszkody(102,51,0,200);
class mucha;

float odleglosc(Vector2f poczatek, Vector2f koniec)
{
    return sqrt(pow((poczatek.x-koniec.x),2)+pow((poczatek.y-koniec.y),2));
}

float minimum(float pierwsza, float druga)
{
    return(pierwsza<druga?pierwsza:druga);
}

class przeszkody
{
    friend mucha;
private:
    int liczbaPrzeszkod=liczbaPrzeszkodStala;
    RectangleShape listaPrzeszkod[liczbaPrzeszkodStala];
public:
    przeszkody();
    RectangleShape* wyslijTablice ();
    int wyslijLiczbaprzeszod();
    RectangleShape wyslijNtaPrzeszkode(int);
};

class mucha : public CircleShape
{
private:
    int licznik;
    Vector2f polozenie;
    Vector2f predkosc;
    bool czyZyje;
    float ocena=0;
    float ocen(RectangleShape przeszkody);
    Vector2f tablicaPredkosc[rozmiarTablica];
public:
    static przeszkody wszystkiePrzeszkody;
    mucha();
    void aktualizuj();
    friend bool czyKolizja(RectangleShape przeszkody[], int liczbaprzeszkod, Vector2f polozenie);
    void mutuj();
    int wyslijLicznik();
    float wyslijOcene();
    friend void krzyzuj(mucha &gorsza, mucha &lepsza1, mucha &lepsza2);
};

przeszkody mucha::wszystkiePrzeszkody;   //INICJALIZACJA STATIC!!!

int przeszkody::wyslijLiczbaprzeszod()
{
    return liczbaPrzeszkod;
}

RectangleShape przeszkody::wyslijNtaPrzeszkode(int n)
{
    return listaPrzeszkod[n];
}

przeszkody::przeszkody()
{
    for(int i=0; i<liczbaPrzeszkod;i++)
    {
        listaPrzeszkod[i].setSize(prostokatRozmiar);
        listaPrzeszkod[i].setPosition(prostokatPoczatek);
        listaPrzeszkod[i].setFillColor(KolorPrzeszkody);
    }

}

int mucha::wyslijLicznik()
{
    return licznik;
}

float mucha::ocen(RectangleShape przeszkody)
{
         if(polozenie.x>przeszkody.getPoint(0).x&&polozenie.x<przeszkody.getPoint(1).x&&polozenie.y<przeszkody.getPoint(0).y)
            return minimum(odleglosc(polozenie,przeszkody.getPoint(0))+odleglosc(przeszkody.getPoint(0),przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu),
                       odleglosc(polozenie,przeszkody.getPoint(1))+odleglosc(przeszkody.getPoint(1),przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu));
         else if(polozenie.y<polozenieCelu.y-abs(polozenie.x-polozenieCelu.x)*(polozenieCelu.y-przeszkody.getPoint(4).y)/(polozenieCelu.x-przeszkody.getPoint(4).x))
            return minimum((odleglosc(polozenie,przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu)),
                       (odleglosc(polozenie,przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu)));

         else
            return odleglosc(polozenie,polozenieCelu);

}

RectangleShape* przeszkody::wyslijTablice()
{
    return listaPrzeszkod;
}

bool czyKolizja(RectangleShape* przeszkody, int liczbaPrzeszkod, Vector2f polozenie)
{
    for(int i=0; i<liczbaPrzeszkod; i++)
    {
        if(polozenie.x>przeszkody[i].getPosition().x&&
           polozenie.x<przeszkody[i].getPosition().x+przeszkody[i].getSize().x&&
           polozenie.y>przeszkody[i].getPosition().y&&
           polozenie.y<przeszkody[i].getPosition().y+przeszkody[i].getSize().y)
            return false;
    }
    return true;
}
mucha::mucha():polozenie(polozeniePoczatkowe), predkosc(predkoscPoczatkowa), czyZyje(true)
{
   for(int i=0; i<rozmiarTablica; i++)
   {
   tablicaPredkosc[i].x=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;             //zastapic funkcja losuj
   tablicaPredkosc[i].y=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;
   }
   setRadius(promien);
   setOrigin(promien, promien);
   setPosition(polozenie);
   setFillColor(Color::Black);

}

float mucha::wyslijOcene()
{
    return ocena;
}
void mucha::mutuj()
{
    for(int i=0; i<rozmiarTablica/dzielnikMutacji;i++)
    {
        tablicaPredkosc[rand() % rozmiarTablica].x+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
        tablicaPredkosc[rand() % rozmiarTablica].y+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
    }
}

void mucha::aktualizuj()
{
    if(licznik<rozmiarTablica&&czyZyje)
    {
    setPosition(polozenie+=predkosc);               //zmienia polozenie a potem wysyla do funkcji setPosition
    predkosc+=tablicaPredkosc[licznik];
    }
    czyZyje=czyKolizja(wszystkiePrzeszkody.wyslijTablice(), wszystkiePrzeszkody.liczbaPrzeszkod, polozenie);

    licznik++;

    if(licznik==rozmiarTablica+200)                 //200, aby muchy od razu nie wracaly do punktu startowego
    {
        polozenie=polozeniePoczatkowe;
        predkosc=predkoscPoczatkowa;
        licznik=0;
        czyZyje=true;
        ocena=ocen(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(0));
    }


}

bool porownuj(mucha mucha1, mucha mucha2)
{
    if(mucha1.wyslijOcene()<=mucha2.wyslijOcene())
        return true;
    else
        return false;
}

void krzyzuj (mucha &gorsza, mucha &lepsza1, mucha &lepsza2)
{
    for(int i=0; i<rozmiarTablica; i++)
    {
        gorsza.tablicaPredkosc[i].x=(i<rozmiarTablica/2?lepsza1.tablicaPredkosc[i].x:lepsza2.tablicaPredkosc[i].x);
        gorsza.tablicaPredkosc[i].y=(i<rozmiarTablica/2?lepsza1.tablicaPredkosc[i].y:lepsza2.tablicaPredkosc[i].y);
    }

}

int main()
{
    srand( time( NULL ) );
    RenderWindow okno(VideoMode(rozmiarOknaX, rozmiarOknaY), "SFML window");
    mucha *muchy=new mucha[liczbaMuch];
   // mucha muchy[liczbaMuch];
    CircleShape cel(promien);
    cel.setOrigin(promien, promien);
    cel.setFillColor(Color::Blue);
    cel.setPosition(polozenieCelu);
    while (okno.isOpen())
    {
        Event event;
        while (okno.pollEvent(event))
        {
            if (event.type == Event::Closed)
                okno.close();
        }

            okno.clear(Color::White);
            for(int i=0; i<liczbaMuch; i++ )
                okno.draw(muchy[i]);
            for(int i=0; i<mucha::wszystkiePrzeszkody.wyslijLiczbaprzeszod(); i++)
                okno.draw(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(i));
            okno.draw(cel);


            okno.display();
            for(int i=0; i<liczbaMuch; i++)
                muchy[i].aktualizuj();
            if(muchy[0].wyslijLicznik()==rozmiarTablica+199)
            {
                for(int i=0; i<liczbaMuch; i++)
                    muchy[i].mutuj();
               sort(muchy, muchy+liczbaMuch, porownuj);
               for(int i=0; i<iloscKrzyzowan; i++)
                   krzyzuj(muchy[i],muchy[liczbaMuch-2*i], muchy[liczbaMuch-2*i-1]);
            }




    }

    return EXIT_SUCCESS;
}

Jestem już przy końcu działającej wersji, mam tylko problem z samą końcówka, więc jakbyś odpowiedział mi na parę pytań (lub ktoś inny byłbym niezmiernie wdzięczny)

Wiem, że jakość kodu nie poraża, Twoje rady jeszcze czekają na zastosowanie, ale bardzo chciałym zobaczyć działającą wersję, a potem oczyścić kod.

Tu dwa problemy które już sam rozwiązałem, więc nie warto czytać :

Ukryta treść:    

Problem mam z funkcją sort(z biblioteki standardowej) i krzyzuj.

1. Funkcja sort działa dla małej ilości much, np. 10 bez żadnego błędu, lecz dla większej ilości much wyrzuca albo bad alloc albo jakiś błąd z numerem z kosmosu.

2. Funkcja krzyzuj (linia 186) te same błędy wyrzuca, jednak dla każdej ilości much. Gdy dodałem asercje w pierwszej linijce tej funkcji, to wykonanie kodu nie doszło do niej, więc problem jest już przy wywołaniu(oczywiscie funkcje sort wykomentowałem)

Przeglądałem informacje o funcji sort, lecz albo jestem ślepy, albo nie ma nic o moim problemie

Edit Z sort sobie poradziłem, zamiast probować szukać w opisie wpisałem sort+bad alloc C++ i na stackoverflow znalazłem w pierwszym linku, z krzyżuj dzieją się dziwne rzeczy dla 50 much nie działa, dla 500 działa, ale nic nie robi, albo nie widzę efektów.Edit 2 Z krzyzuj przy wowyłaniu był problem z zakresem tablic, muszę wreszcie zmusić się do używania vectora, bo on ma automatyczne sprawdzenie zakresów

Mam też następujący problem, ale on tyczy się już SFLM, więc jeśli w nim nie siedziałeś, to nie chcę Ci zajmować czasu, bardziej liczę na osoby, które używały tej biblioteki (chyba, że też Łukasz używałeś go )poza funkcjami inicjować zmienne można tylko przy deklaracji/definicji.
Jednak mam taki problem, że chcę mieć globalną tablicę Vector2f, jednak przy probie inicjalizacji dostaje zwrotną informację od kompilatora, że nieudana konwersja z int do Vector2f, jak sobie z tym poradzić.

Kod: Zaznacz cały

const Vector2f prostokatPoczatek(400,400);
//const Vector2f prostokat[1]{(400,400)};   //???

Kolejny już edit

Ukryta treść:    

Kod: Zaznacz cały

#include <SFML/Graphics.hpp>
#include <cmath>
#include <algorithm>
#include <cassert>

using namespace sf;
using namespace std;

const int rozmiarOknaX=1200;
const int rozmiarOknaY=800;
const int rozmiarTablica=2500;
const float dzielnikPredkosc=2000000;


const Vector2f prostokatPoczatek0(300,0);
const Vector2f prostokatRozmiar0(600,100);
const Vector2f prostokatPoczatek1(0,0);
const Vector2f prostokatRozmiar1(rozmiarOknaX,5);
const Vector2f prostokatPoczatek2(0,0);
const Vector2f prostokatRozmiar2(5,rozmiarOknaY);
const Vector2f prostokatPoczatek3(rozmiarOknaX-5,5);
const Vector2f prostokatRozmiar3(5,rozmiarOknaY);
const Vector2f prostokatPoczatek4(5,rozmiarOknaY-5);
const Vector2f prostokatRozmiar4(rozmiarOknaX,5);
const int liczbaPrzeszkodStala=5;


const int liczbaMuch=300;
const int liczbaTur=100;
const Vector2f polozeniePoczatkowe(rozmiarOknaX/2,100);
const Vector2f predkoscPoczatkowa(0,0.25);
const Vector2f polozenieCelu(rozmiarOknaX/2, rozmiarOknaY-100);
const float promien=5;
const int dzielnikMutacji=1000;
const int iloscKrzyzowan=liczbaMuch/20;

Color KolorPrzeszkody(102,51,0,200);
class mucha;


float odleglosc(Vector2f poczatek, Vector2f koniec)
{
    return sqrt(pow((poczatek.x-koniec.x),2)+pow((poczatek.y-koniec.y),2));
}

float minimum(float pierwsza, float druga)
{
    return(pierwsza<druga?pierwsza:druga);
}

class przeszkody
{
    friend mucha;
private:
    int liczbaPrzeszkod=liczbaPrzeszkodStala;
    RectangleShape listaPrzeszkod[liczbaPrzeszkodStala];
public:
    przeszkody();
    RectangleShape* wyslijTablice ();
    int wyslijLiczbaprzeszod();
    RectangleShape wyslijNtaPrzeszkode(int);
};

class mucha : public CircleShape
{
private:
    int licznik;
    Vector2f polozenie;
    Vector2f predkosc;
    bool czyZyje;
    float ocena=0;
    float ocen(RectangleShape przeszkody);
    Vector2f tablicaPredkosc[rozmiarTablica];
public:
    static przeszkody wszystkiePrzeszkody;
    mucha();
    void aktualizuj();
    friend bool czyKolizja(RectangleShape przeszkody[], int liczbaprzeszkod, Vector2f polozenie);
    void mutuj();
    int wyslijLicznik();
    float wyslijOcene();
    friend void krzyzuj(mucha &gorsza, mucha &lepsza1, mucha &lepsza2);
};

przeszkody mucha::wszystkiePrzeszkody;   //INICJALIZACJA STATIC!!!

int przeszkody::wyslijLiczbaprzeszod()
{
    return liczbaPrzeszkod;
}

RectangleShape przeszkody::wyslijNtaPrzeszkode(int n)
{
    return listaPrzeszkod[n];
}

przeszkody::przeszkody()
{
        listaPrzeszkod[0].setSize(prostokatRozmiar0);
        listaPrzeszkod[0].setPosition(prostokatPoczatek0);
        listaPrzeszkod[0].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[1].setSize(prostokatRozmiar1);
        listaPrzeszkod[1].setPosition(prostokatPoczatek1);
        listaPrzeszkod[1].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[2].setSize(prostokatRozmiar2);
        listaPrzeszkod[2].setPosition(prostokatPoczatek2);
        listaPrzeszkod[2].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[3].setSize(prostokatRozmiar3);
        listaPrzeszkod[3].setPosition(prostokatPoczatek3);
        listaPrzeszkod[3].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[4].setSize(prostokatRozmiar4);
        listaPrzeszkod[4].setPosition(prostokatPoczatek4);
        listaPrzeszkod[4].setFillColor(KolorPrzeszkody);

}

int mucha::wyslijLicznik()
{
    return licznik;
}

float mucha::ocen(RectangleShape przeszkody)
{
    if(polozenie.x>przeszkody.getPoint(0).x&&polozenie.x<przeszkody.getPoint(1).x&&polozenie.y<przeszkody.getPoint(0).y)
        return minimum((odleglosc(polozenie,przeszkody.getPoint(0))+odleglosc(przeszkody.getPoint(0),przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu)),
                odleglosc(polozenie,przeszkody.getPoint(1))+odleglosc(przeszkody.getPoint(1),przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu));
    else if (((polozenieCelu.y-polozenie.y)/(abs(polozenieCelu.x-polozenie.x)))
                >=((polozenieCelu.y-przeszkody.getPoint(3).y)/(polozenieCelu.x-przeszkody.getPoint(3).x)))
        return minimum((odleglosc(polozenie,przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu)),
                       (odleglosc(polozenie,przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu)));
    else
        return odleglosc(polozenie,polozenieCelu);

}

RectangleShape* przeszkody::wyslijTablice()
{
    return listaPrzeszkod;
}

bool czyKolizja(RectangleShape* przeszkody, int liczbaPrzeszkod, Vector2f polozenie)
{
    for(int i=0; i<liczbaPrzeszkod; i++)
    {
        if(polozenie.x>przeszkody[i].getPosition().x&&
           polozenie.x<przeszkody[i].getPosition().x+przeszkody[i].getSize().x&&
           polozenie.y>przeszkody[i].getPosition().y&&
           polozenie.y<przeszkody[i].getPosition().y+przeszkody[i].getSize().y)
            return false;
    }
    return true;
}
mucha::mucha():polozenie(polozeniePoczatkowe), predkosc(predkoscPoczatkowa), czyZyje(true)
{
   for(int i=0; i<rozmiarTablica; i++)
   {
   tablicaPredkosc[i].x=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;             //zastapic funkcja losuj
   tablicaPredkosc[i].y=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;
   }
   setRadius(promien);
   setOrigin(promien, promien);
   setPosition(polozenie);
   setFillColor(Color::Black);

}

float mucha::wyslijOcene()
{
    return ocena;
}
void mucha::mutuj()
{
    for(int i=0; i<rozmiarTablica/dzielnikMutacji;i++)
    {
        tablicaPredkosc[rand() % rozmiarTablica].x+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
        tablicaPredkosc[rand() % rozmiarTablica].y+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
    }
}

void mucha::aktualizuj()
{
    if(licznik<rozmiarTablica&&czyZyje)
    {
    setPosition(polozenie+=predkosc);               //zmienia polozenie a potem wysyla do funkcji setPosition
    predkosc+=tablicaPredkosc[licznik];
    }
    czyZyje=czyKolizja(wszystkiePrzeszkody.wyslijTablice(), wszystkiePrzeszkody.liczbaPrzeszkod, polozenie);

    licznik++;

    if(licznik==rozmiarTablica+200)                 //200, aby muchy od razu nie wracaly do punktu startowego
    {
        polozenie=polozeniePoczatkowe;
        predkosc=predkoscPoczatkowa;
        licznik=0;
        czyZyje=true;
        ocena=ocen(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(0));
    }


}

bool porownuj(mucha mucha1, mucha mucha2)
{
    if(mucha1.wyslijOcene()<mucha2.wyslijOcene())
        return true;
    else
        return false;
}

void krzyzuj (mucha &gorsza, mucha &lepsza1, mucha &lepsza2)
{
    for(int i=0; i<rozmiarTablica; i++)
    {
        gorsza.tablicaPredkosc[i].x=(lepsza1.tablicaPredkosc[i].x+lepsza2.tablicaPredkosc[i].x)/2;
        gorsza.tablicaPredkosc[i].y=(lepsza1.tablicaPredkosc[i].y+lepsza2.tablicaPredkosc[i].y)/2;
    }
    lepsza1.setFillColor(Color::Red);
    lepsza2.setFillColor(Color::Red);

}

int main()
{
    srand( time( NULL ) );
    RenderWindow okno(VideoMode(rozmiarOknaX, rozmiarOknaY), "SFML window");
    mucha *muchy=new mucha[liczbaMuch];
   // mucha muchy[liczbaMuch];
    CircleShape cel(promien);
    cel.setOrigin(promien, promien);
    cel.setFillColor(Color::Blue);
    cel.setPosition(polozenieCelu);
    while (okno.isOpen())
    {
        Event event;
        while (okno.pollEvent(event))
        {
            if (event.type == Event::Closed)
                okno.close();
        }

            okno.clear(Color::White);
            for(int i=0; i<liczbaMuch; i++ )
                okno.draw(muchy[i]);
            for(int i=0; i<mucha::wszystkiePrzeszkody.wyslijLiczbaprzeszod(); i++)
                okno.draw(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(i));
            okno.draw(cel);


            okno.display();
            for(int i=0; i<liczbaMuch; i++)
                muchy[i].aktualizuj();
            if(muchy[0].wyslijLicznik()==rozmiarTablica+199)
            {
                for(int i=0; i<liczbaMuch; i++)
                    muchy[i].mutuj();
               sort(muchy, muchy+liczbaMuch, porownuj);
              for(int i=0; i<iloscKrzyzowan; i++)
                   krzyzuj(muchy[i],muchy[liczbaMuch-2*i-1], muchy[liczbaMuch-2*i-2]);
            }




    }

    return EXIT_SUCCESS;
}

Tutaj jest działająca wersja, maluje najlepsze muchy na czerwono (w funkcji krzyżuj) i zauważyłem, że wcale nie te najlepsze muchy są malowane na czerwono, czyli funkcja sort nie sortuje, masz pomysł dlaczego? Z góry dziękuję

[lukequaint]

Wcześniejszy problem:

• wywołaj jawnie konstruktor

  Kod: Zaznacz cały

  const Vector2f prostokat[1]{Vector2f(400,400)};
  

• albo użyj klamerek

  Kod: Zaznacz cały

  const Vector2f prostokat[1]{{400,400}};
  

Co do sortowania, wyświetl wyliczane oceny, to szybko zauważysz przyczynę problemu. Z tego, co widzę, wszystkie muchy od pewnego momentu mają ocenę \(\displaystyle{ 600}\) (nie zagłębiałem się w kod, może one gdzieś tam giną, ale i tak ocena przyjmuje tylko dwie wartości: \(\displaystyle{ 0}\) i \(\displaystyle{ 600}\), na tej podstawie nie można ich posortować).

[gabrysb1995]

Ukryta treść:    

Kod: Zaznacz cały

#include <SFML/Graphics.hpp>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <iostream>

using namespace sf;
using namespace std;

const int rozmiarOknaX=1200;
const int rozmiarOknaY=800;
const int rozmiarTablica=2500;
const float dzielnikPredkosc=2000000;


const Vector2f prostokatPoczatek0(300,0);
const Vector2f prostokatRozmiar0(600,100);
const Vector2f prostokatPoczatek1(0,0);
const Vector2f prostokatRozmiar1(rozmiarOknaX,5);
const Vector2f prostokatPoczatek2(0,0);
const Vector2f prostokatRozmiar2(5,rozmiarOknaY);
const Vector2f prostokatPoczatek3(rozmiarOknaX-5,5);
const Vector2f prostokatRozmiar3(5,rozmiarOknaY);
const Vector2f prostokatPoczatek4(5,rozmiarOknaY-5);
const Vector2f prostokatRozmiar4(rozmiarOknaX,5);
const int liczbaPrzeszkodStala=5;


const int liczbaMuch=100;
const int liczbaTur=100;
const Vector2f polozeniePoczatkowe(rozmiarOknaX/2,100);
const Vector2f predkoscPoczatkowa(0,0.25);
const Vector2f polozenieCelu(rozmiarOknaX/2, rozmiarOknaY-200);
const float promien=5;
const int dzielnikMutacji=1000;
const int iloscKrzyzowan=liczbaMuch/20;

Color KolorPrzeszkody(102,51,0,200);
class mucha;


float odleglosc(Vector2f poczatek, Vector2f koniec)
{
    return sqrt(pow((poczatek.x-koniec.x),2)+pow((poczatek.y-koniec.y),2));
}

float minimum(float pierwsza, float druga)
{
    return(pierwsza<druga?pierwsza:druga);
}

class przeszkody
{
    friend mucha;
private:
    int liczbaPrzeszkod=liczbaPrzeszkodStala;
    RectangleShape listaPrzeszkod[liczbaPrzeszkodStala];
public:
    przeszkody();
    RectangleShape* wyslijTablice ();
    int wyslijLiczbaprzeszod();
    RectangleShape wyslijNtaPrzeszkode(int);
};

class mucha : public CircleShape
{
private:
    int licznik;
    Vector2f polozenie;
    Vector2f predkosc;
    bool czyZyje;
    float ocena=0;
    float ocen(RectangleShape przeszkody);
    Vector2f tablicaPredkosc[rozmiarTablica];
public:
    static przeszkody wszystkiePrzeszkody;
    mucha();
    void aktualizuj();
    friend bool czyKolizja(RectangleShape przeszkody[], int liczbaprzeszkod, Vector2f polozenie);
    void mutuj();
    int wyslijLicznik();
    float wyslijOcene();
    friend void krzyzuj(mucha &gorsza, mucha &lepsza1, mucha &lepsza2);
};

przeszkody mucha::wszystkiePrzeszkody;   //INICJALIZACJA STATIC!!!

int przeszkody::wyslijLiczbaprzeszod()
{
    return liczbaPrzeszkod;
}

RectangleShape przeszkody::wyslijNtaPrzeszkode(int n)
{
    return listaPrzeszkod[n];
}

przeszkody::przeszkody()
{
        listaPrzeszkod[0].setSize(prostokatRozmiar0);
        listaPrzeszkod[0].setPosition(prostokatPoczatek0);
        listaPrzeszkod[0].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[1].setSize(prostokatRozmiar1);
        listaPrzeszkod[1].setPosition(prostokatPoczatek1);
        listaPrzeszkod[1].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[2].setSize(prostokatRozmiar2);
        listaPrzeszkod[2].setPosition(prostokatPoczatek2);
        listaPrzeszkod[2].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[3].setSize(prostokatRozmiar3);
        listaPrzeszkod[3].setPosition(prostokatPoczatek3);
        listaPrzeszkod[3].setFillColor(KolorPrzeszkody);
        listaPrzeszkod[4].setSize(prostokatRozmiar4);
        listaPrzeszkod[4].setPosition(prostokatPoczatek4);
        listaPrzeszkod[4].setFillColor(KolorPrzeszkody);

}

int mucha::wyslijLicznik()
{
    return licznik;
}

float mucha::ocen(RectangleShape przeszkody)
{
    if(polozenie.x>przeszkody.getPoint(0).x&&polozenie.x<przeszkody.getPoint(1).x&&polozenie.y<przeszkody.getPoint(0).y)
        return minimum((odleglosc(polozenie,przeszkody.getPoint(0))+odleglosc(przeszkody.getPoint(0),przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu)),
                odleglosc(polozenie,przeszkody.getPoint(1))+odleglosc(przeszkody.getPoint(1),przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu));
    else if (((polozenieCelu.y-polozenie.y)/(abs(polozenieCelu.x-polozenie.x)))
                >=((polozenieCelu.y-przeszkody.getPoint(3).y)/(polozenieCelu.x-przeszkody.getPoint(3).x)))
        return minimum((odleglosc(polozenie,przeszkody.getPoint(2))+odleglosc(przeszkody.getPoint(2),polozenieCelu)),
                       (odleglosc(polozenie,przeszkody.getPoint(3))+odleglosc(przeszkody.getPoint(3),polozenieCelu)));
    else
        return odleglosc(polozenie,polozenieCelu);

}

RectangleShape* przeszkody::wyslijTablice()
{
    return listaPrzeszkod;
}

bool czyKolizja(RectangleShape* przeszkody, int liczbaPrzeszkod, Vector2f polozenie)
{
    for(int i=0; i<liczbaPrzeszkod; i++)
    {
        if(polozenie.x>przeszkody[i].getPosition().x&&
           polozenie.x<przeszkody[i].getPosition().x+przeszkody[i].getSize().x&&
           polozenie.y>przeszkody[i].getPosition().y&&
           polozenie.y<przeszkody[i].getPosition().y+przeszkody[i].getSize().y)
            return false;
    }
    return true;
}
mucha::mucha():polozenie(polozeniePoczatkowe), predkosc(predkoscPoczatkowa), czyZyje(true)
{
   for(int i=0; i<rozmiarTablica; i++)
   {
   tablicaPredkosc[i].x=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;             //zastapic funkcja losuj
   tablicaPredkosc[i].y=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc;
   }
   setRadius(promien);
   setOrigin(promien, promien);
   setPosition(polozenie);
   setFillColor(Color::Black);

}

float mucha::wyslijOcene()
{
    return ocena;
}
void mucha::mutuj()
{
    for(int i=0; i<rozmiarTablica/dzielnikMutacji;i++)
    {
        tablicaPredkosc[rand() % rozmiarTablica].x+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
        tablicaPredkosc[rand() % rozmiarTablica].y+=(rand()%2==0?1:-1)*rand()/dzielnikPredkosc/10;
    }
}

void mucha::aktualizuj()
{
    if(licznik<rozmiarTablica&&czyZyje)
    {
    setPosition(polozenie+=predkosc);               //zmienia polozenie a potem wysyla do funkcji setPosition
    predkosc+=tablicaPredkosc[licznik];
    }
    czyZyje=czyKolizja(wszystkiePrzeszkody.wyslijTablice(), wszystkiePrzeszkody.liczbaPrzeszkod, polozenie);

    licznik++;

    if(licznik==rozmiarTablica+200)                 //200, aby muchy od razu nie wracaly do punktu startowego
    {
        licznik=0;
        czyZyje=true;
        ocena=ocen(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(0));
        polozenie=polozeniePoczatkowe;
        predkosc=predkoscPoczatkowa;
   //     cout << wyslijOcene() <<endl;
    }


}

bool porownuj(mucha mucha1, mucha mucha2)
{
    if(mucha1.wyslijOcene()>mucha2.wyslijOcene())
        return true;
    else
        return false;
}

void krzyzuj (mucha &gorsza, mucha &lepsza1, mucha &lepsza2)
{
    for(int i=0; i<rozmiarTablica; i++)
    {
        gorsza.tablicaPredkosc[i].x=(lepsza1.tablicaPredkosc[i].x+lepsza2.tablicaPredkosc[i].x)/2;
        gorsza.tablicaPredkosc[i].y=(lepsza1.tablicaPredkosc[i].y+lepsza2.tablicaPredkosc[i].y)/2;
    }
    lepsza1.setFillColor(Color::Red);
    lepsza2.setFillColor(Color::Red);

}

int main()
{
    srand( time( NULL ) );
    RenderWindow okno(VideoMode(rozmiarOknaX, rozmiarOknaY), "SFML window");
    mucha *muchy=new mucha[liczbaMuch];
   // mucha muchy[liczbaMuch];
    CircleShape cel(promien);
    cel.setOrigin(promien, promien);
    cel.setFillColor(Color::Blue);
    cel.setPosition(polozenieCelu);
    while (okno.isOpen())
    {
        Event event;
        while (okno.pollEvent(event))
        {
            if (event.type == Event::Closed)
                okno.close();
        }

            okno.clear(Color::White);
            for(int i=0; i<liczbaMuch; i++ )
                okno.draw(muchy[i]);
            for(int i=0; i<mucha::wszystkiePrzeszkody.wyslijLiczbaprzeszod(); i++)
                okno.draw(mucha::wszystkiePrzeszkody.wyslijNtaPrzeszkode(i));
            okno.draw(cel);


            okno.display();
            for(int i=0; i<liczbaMuch; i++)
                muchy[i].aktualizuj();
            if(muchy[0].wyslijLicznik()==rozmiarTablica+199)
            {
                for(int i=0; i<liczbaMuch; i++)
                    muchy[i].mutuj();
               sort(muchy, muchy+liczbaMuch, porownuj);

             //  for(int i=0; i<liczbaMuch; i++)
            //        cout << muchy[i].wyslijOcene() << endl;

              for(int i=0; i<iloscKrzyzowan; i++)
                   krzyzuj(muchy[i],muchy[liczbaMuch-2*i-1], muchy[liczbaMuch-2*i-2]);
            }




    }

    return EXIT_SUCCESS;
}

Dzięki jeszcze raz, jawny konstruktor zadziałał, nie pomyślałem o tym, jeszcze dużo mi brakuje.

Mam ostatnie pytanie, bo już wszystko działa, poza jedną rzeczą, w pierwszej turze sortowanie nie działa. Gdy wypisuje ocenę w aktualizuj() to wszystko jest ok, ale jak po sortowaniu w main, to mam opóźnienie i najpierw same zera wypisuje, masz jakiś pomysł? Jeszcze raz dziękuję

[lukequaint]

Jeśli dobrze widzę, to dzieje się tak, bo w funkcji main() wypisujesz oceny, gdy

Kod: Zaznacz cały

licznik == rozmiarTablica + 199

a w funkcji aktualizuj() ustawiasz ocenę na \(\displaystyle{ !=0}\) i ją wypisujesz dopiero, gdy

Kod: Zaznacz cały

licznik == rozmiarTablica + 200

czyli o krok później.

Mogę Ci doradzić dwie rzeczy:

• wypisuj wartości zmiennych w jednym miejscu lub pod spójnym warunkiem, np. określonym przez wynik jakiejś funkcji (mam na myśli if z wywołaniem funkcji zaraz przed wypisaniem wartości; możesz też przeanalizować program jakimś debuggerem i tam ładnie podejrzeć wartości poszczególnych zmiennych)
• oznaczaj w jakiś specjalny sposób składowe klas, np. przedrostkiem m_, _ lub przyrostkiem _; dużo łatwiej czyta się wtedy kod - wiadomo, czy w danym miejscu zmieniamy wartość składowej jednego obiektu, drugiego, zmiennej lokalnej zdefiniowanej trzydzieści linijek wyżej czy zmiennej globalnej z innego pliku