Symulacja, problem sfml

0

main:

///////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include "headers.h"
#include "Ground.h"
#include "MakeWorm.h"



int main()
{

    
    
    sf::Clock clock;
    int framesCounter = 0;//licznik klatek
    Motion random; // obiekt do losowania kierunku
    random.randGenerator();//generator losowosci
//    int amount = INITIAL_AMOUNT_OF_WORMS;
//    Worm * worm = new Worm[amount];
//
//    
//    for (int i = 0; i < amount; i++) { 
//        
//        int * tabXY = random.getRandomPosition();
//        
//        worm[i].makeWorm(tabXY[0], tabXY[1]);
//        
//        delete [] tabXY;
//    }
    
    MakeWorm worm(random);
    
   // worm.newWorm(5, random);
        
        
    sf::RenderWindow window(sf::VideoMode(SCREEN_WIDTH, SCREEN_HEIGHT), "Hodowla Robakow");
    
    // run the program as long as the window is open
    while (window.isOpen())
    {
        
        framesCounter++;
        sf::Time elapsed1 = clock.getElapsedTime();
        float time = elapsed1.asSeconds();
        int fps = framesCounter/time;
        
        
        // check all the window's events that were triggered since the last iteration of the loop
        sf::Event event;
        while (window.pollEvent(event))
        {
            // "close requested" event: we close the window
            if (event.type == sf::Event::Closed)
                window.close();
        }

        // clear the window with black color
        window.clear(sf::Color::Black);

        // draw everything here...
        // window.draw(...);
      
        
        
        sf::Font font;
        if (!font.loadFromFile("DejaVuSans.ttf"))
        {
         // error...
         }//ladowanie czcionki
       
        //////////TEKST FPS//////////////////////////////////
        sf::Text text;
        text.setFont(font); 
        text.setString(std::to_string(fps) + " fps");
        text.setCharacterSize(20); // in pixels, not points!
        text.setFillColor(sf::Color::Red);
        text.setStyle(sf::Text::Bold);
        /////////////////////////////////////////////////////
  
        //tlo
        Ground floor;        
        floor.printGround(SCREEN_HEIGHT, SCREEN_WIDTH, GROUND_TEXTURE_PATH);

        //rysowanie
        window.draw(floor.rectangle); //tlo
        
        
        //ruchy robakow
           
                 worm.move(random);   
  
        //rysowanie robakow
        for(int x = 0; x < 50; x++)
        {
            std::cout<<"xd";
        window.draw(worm.worm[x].getWorm());
        }
        
         //end the current frame
        
        window.draw(text); //fpsy

        window.display();
        
        
        
    }
   

   
    worm.releaseWorms();

   return 0;
}

klasa MakeWorm:

#include "MakeWorm.h"

    MakeWorm::MakeWorm(Motion random) {
        
        this->worm = new Worm[this->WormAmount];
        std::cout<<"constructor ilosc robali: "<<this->WormAmount<<std::endl;
        
        
        for (int i = 0; i < this->WormAmount; i++) { 
        
        int * tabXY = random.getRandomPosition();
        this->worm->makeWorm(tabXY[0], tabXY[1]);
        delete [] tabXY;
        
        std::cout<<"constructor worm created"<<std::endl;
        } 
        
        
    }

    int MakeWorm::getWormAmount() {
        
        return this->WormAmount;
        
    }
    
    void MakeWorm::newWorm(int amount, Motion random) {
        
        this->worm = new Worm[amount];
        
        
        
        for (int i = 0; i < amount; i++) { 
        
        int * tabXY = random.getRandomPosition();
        this->worm->makeWorm(tabXY[0], tabXY[1]);
        delete [] tabXY;
        
        std::cout<<"new worm created"<<std::endl;
        }
        this->WormAmount=this->WormAmount+amount;
        
    }
    
    
    void MakeWorm::releaseWorms() {
        
        delete [] worm;
        
    }
    
    void MakeWorm::move(Motion random) {
        
        for (int i = 0; i < this->WormAmount; i++)
        {
            std::cout<<"worm "<<i<<": ";
        this->worm[i].randomizeWormMovement(random);
        }
        
        
    }//losowe poruszanie sie wszystkich robaków
    
    sf::Sprite MakeWorm::getworm(int x) {
        
        return this->worm[x].getWorm();
        
        
    }

klasa Worm:

#include "Worm.h"
//#include <Vector2.cpp>



    void Worm::setSex(bool newSex){
        
        this->sex = newSex;    
        
    }
    
    
    void Worm::setAge(bool newAge){
        
        this->age = newAge;
          
    }
    

    
    void Worm::loadWormTexture(std::string path) {
    
    //this->wormMaleTexture.create(80, 80);
    
    if(!wormMaleTexture.loadFromFile(path)) {
        std::cout<<"Worm texture loaded.\n";
    }
    
        //blad
    
    
    }
    
    void Worm::loadMovingWormTexture(std::string path) {
        
        
    if(!movingWormMaleTexture.loadFromFile(path)) {
        std::cout<<"Worm texture loaded.\n";
    }
    else
        std::cout<<"Can't load second worm texture.\n";
        
        
        
    }
    
    
    
     void Worm::setWormTexture(int x){
         
         
         switch(x) {
             
             case 1:  this->worm.setTexture(this->wormMaleTexture); break;
             case 2:  this->worm.setTexture(this->movingWormMaleTexture); break;
             
         }
        
         
         
     }
     
     sf::Sprite Worm::makeWorm(int x, int y){
         
        loadWormTexture(MALE_WORM_TEXTURE_PATH);
        loadMovingWormTexture(MALE_WORM_MOVE_TEXTURE_PATH);
        
        
        this->worm.setPosition(sf::Vector2f(x, y));
         
        return this->worm; 
         
     }
     
     
     sf::Sprite Worm::moveWorm(float x, float y){
         
        //stepsCounter++;
        
        if(stepsCounter%14+1==7){
            setWormTexture(1);
        }
        else if (stepsCounter%14+1==14){
            
            setWormTexture(2);
            
        }
         
        
        //animacja robala
        //this->worm.setPosition(pos_x, pos_y);
        this->worm.move(x, y);
        
        
     }
     
  
     
     
     sf::Sprite Worm::getWorm(){
         
       return this->worm;  
         
     }
     
     
     ///////////////////////////////////////////////////////////////////// KROKI ///////////////////////////////////////
     
     void Worm::changeSteps(int steps) {
         
         this->stepsCounter = steps;
         
     }
     
     int Worm::getSteps() {
         
         return this->stepsCounter;
                
     }
     
     ///////////////////////////////////////////////////////////////////KIERUNEK////////////////////////////////////////
    void Worm::rotateWorm(double angle) {
         
     this->worm.setRotation(angle);  
         
         
     }
    double Worm::getRotation() {
        
        return worm.getRotation();
        
    }
    double Worm::getDirX() {
        
         return this->dir_x;
        
    }
     
    double Worm::getDirY()    {
        
         return this->dir_y;
        
    }
    
    void Worm::setDirX(double x) {
        
        this->dir_x = x;
        
    }
    
    void Worm::setDirY(double y) {
        
        this->dir_y = y;
        
    }
    
    
    
    //////////////////////////////////////////////////////////////////////////KONTROLA POZYCJI/////////////////////////////
    bool Worm::inWindow() {
        
        sf::Vector2f pos = worm.getPosition();
        
        if(pos.x>SCREEN_WIDTH-500||pos.y>SCREEN_HEIGHT-210||pos.x<=0||pos.y<=0) {
          
            return true;
            
        }
        else {
            
            return false;
            
        }
            
        
        
        
    }
    
    
    
    
    float Worm::getPosX() {
        
        sf::Vector2f pos = worm.getPosition();
        return pos.x;
        
    }
    
    float Worm::getPosY(){
        
        sf::Vector2f pos = worm.getPosition();
       return pos.y; 
        
        
    }
    ////////////////////////////////////////////////////LOSOWANIE////////////////////////////////////////
    void Worm::randomizeWormMovement(Motion random) {
                    
                    while(inWindow()) {
                        
                    random.wormMotion(getPosX(), getPosY());    
                    Worm::rotateWorm(random.getRandomAngle());      
                    Worm::setDirX(random.getRandomX()); 
                    Worm::setDirY(random.getRandomY());  
                        
                    moveWorm(getDirX(), getDirY());  
                    }
                    
                    if (getSteps() == 0) {
                    random.wormMotion(getPosX(), getPosY());    
                    Worm::rotateWorm(random.getRandomAngle());      
                    Worm::setDirX(random.getRandomX()); 
                    Worm::setDirY(random.getRandomY());
                    
                    changeSteps(random.getRandomSteps());  
                    
                    }
                    
                    moveWorm(getDirX(), getDirY());
                    
                    changeSteps(getSteps()-1);
                    
                    std::cout
                    <<"x: "<<getDirX()
                    <<" y: "<<getDirY()
                    <<" steps: "<<getSteps()
                    <<" rotation: "<<getRotation()
                    <<std::endl;
                                     
    
    }

Mam problem, program wyżej to symulacja robaków, niestety, po stworzeniu klasy MakeWorm, wyświetla mi się tylko jeden. Nie mam pojęcia w którym miejscu mam błąd. Proszę o pomoc!

1
void MakeWorm::newWorm(int amount, Motion random) {
 
        this->worm = new Worm[amount];

Tu masz wyciek pamięci i (chyba) źródło błędu.

0
Delor napisał(a):
void MakeWorm::newWorm(int amount, Motion random) {
 
        this->worm = new Worm[amount];

Tu masz wyciek pamięci i (chyba) źródło błędu.

Poprawiłem, niestety to nie ten błąd, w mainie używam tylko konstruktora do inicjowania objektów.

0

No to patrzymy na konstruktor:

MakeWorm::MakeWorm(Motion random) {
 
        this->worm = new Worm[this->WormAmount];

Ile wynosi this->WormAmount?

0
Delor napisał(a):

No to patrzymy na konstruktor:

MakeWorm::MakeWorm(Motion random) {
 
        this->worm = new Worm[this->WormAmount];

Ile wynosi this->WormAmount?

50

0
    if(!wormMaleTexture.loadFromFile(path)) {
        std::cout<<"Worm texture loaded.\n";
    }

https://www.sfml-dev.org/documentation/2.5.0/classsf_1_1Texture.php#a8e1b56eabfe33e2e0e1cb03712c7fcc7

Returns
True if loading was successful

0
Delor napisał(a):
    if(!wormMaleTexture.loadFromFile(path)) {
        std::cout<<"Worm texture loaded.\n";
    }

https://www.sfml-dev.org/documentation/2.5.0/classsf_1_1Texture.php#a8e1b56eabfe33e2e0e1cb03712c7fcc7

Returns
True if loading was successful

Zmieniłem ;)

0
void Worm::randomizeWormMovement(Motion random) {
                    while(inWindow()) {
                     ... 
                    moveWorm(getDirX(), getDirY());
                    }

??

0

Odwoływałem się do wskaźnika zamiast do tablicy w konstruktorze.

0

Poddaję się. Sformatuj kod. Ponazywaj odpowiednio zmienne i metody.
worm to jednocześnie:

  • obiekt MakeWorm w main()
  • tablica Worm w MakeWorm
  • obiekt w Worm

Metody zwracają/robią co innego niż sugeruje nazwa (inWindow(),makeWorm() zamiast initWorm() itp.).
Przez to ciężko się czyta i analizuje oraz łatwo o pomyłkę.

1 użytkowników online, w tym zalogowanych: 0, gości: 1