Tableau de VertexArray

[zimzim]

Bonjour à tous,

Tous nouveau sur le forum et dans le monde de la programmation C++.
( Je suis web dev PHP/Symfony2)

Donc my problem is:
Je ne comprend pas comment je peux faire/ je suis totalement pommé....

Je m'explique

J'ai compris le principe des shapes etc.( ca marche du feu de dieu par rapport a canvas
Je veux déporter mon traitement dans mon objet Game.
Jusqu'ici tous vas bien.
Mon problème est que je veux stocker dans cette objet Game ma bordure du jeu .
En clair 4 Object VertexArray dans un tableau de VertexArray.
Pour pouvoir créer mes bordures du jeu en init et ne faire que les dessiner dans le refresh.

Or ça fais 1 journée que j'essaye mais j'ai toujours des problème de mémoire ou de cast !

Si une bonne âme charitable peux m'aider.
Je vous joint le code qui me pose problème :
 GAME::CreateBorder()
 GAME::generateBorder()

En sachant que je veux juste comprendre le principe de comment faire un tableau de tableau de vertexArray.

D'avance Merci !


main.cpp

#include <SFML/Graphics.hpp>
#include "ItemGame.h"
#include "Game.h"
#include "Utility.h"

using namespace sf;
using namespace std;


int main()
{
        Game game;
        game.init();
        game.run();

    return 0;
}
 

Game.h

#ifndef GAME_ZIM
#define GAME_ZIM

#include <SFML\Graphics.hpp>
#include "Map.h"
#include "Utility.h"
#include "ItemGame.h"
#include "Wall.h"
#include <memory>

using namespace sf;
using namespace std;

const int screen_w = 1200, screen_h = 900, tile_w =10, tile_h = 10, nb_elements = 1, nb_barriers = 5, nb_border = 4;

class Game
{
        public:
                Game();
                ~Game();
                Map *map;
                RenderWindow* window;
                ItemGame* itemGames[nb_elements];
                vector<Wall*> wall;
                void Game::init();
                void Game::generateMap();
                void Game::createBorder();
                void Game::generateBorder();
                void Game::updateView();
                void Game::refresh();
                void Game::run();

                void addWall(Wall *_wall);
};

#endif GAME_ZIM
 

game.cpp

#include "Game.h"


using namespace sf;
using namespace std;


Game::Game()
{
        ContextSettings antialiasing;
        antialiasing.antialiasingLevel = 32;
        window = new RenderWindow(VideoMode(screen_w, screen_h), "SFML works!", Style::Default, antialiasing);
        window->setFramerateLimit(60);
}


Game::~Game()
{

}

void Game::init()
{
        this->createBorder();
}

void Game::generateMap()
{
        map = new Map(screen_w, screen_h, tile_w, tile_h);

}

void Game::addWall(Wall *_wall)
{
        wall.push_back(_wall);
}

void Game::createBorder()
{
        VertexArray *lineBottom;
        Wall *wall;
        lineBottom = new VertexArray(Lines, 2);
        lineBottom->append(Vertex(this->map->bottomLeft, Color::White));
        lineBottom->append(Vertex(this->map->bottomRight, Color::White));      

        wall = new Wall();
        wall->wall = lineBottom;

}

void Game::generateBorder()
{
        for(int i(0); i < wall.size(); i++)
        {
                window->draw(wall[i]->wall);
        }
}


void Game::run()
{
        while (window->isOpen())
    {
        sf::Event event;
        while (window->pollEvent(event))
        {
            if (event.type == Event::Closed)
                window->close();
        }

                this->refresh();
        }
}

void Game::updateView()
{
        generateBorder();
}

void Game::refresh()
{      
        window->clear();
       
        updateView();

        window->display();
}

 

Wall.h

#pragma once

#include <SFML/Graphics.hpp>
#include "Utility.h"

using namespace std ;
using namespace sf ;

class Wall
{
        public:
                Wall() ;
                Wall(VertexArray const& _wall);
                VertexArray getWall();
                VertexArray wall;
};

 

wall.cpp

#include "Wall.h"

Wall::Wall()
{

}

Wall::Wall(VertexArray const& _wall)
{
        wall = _wall;
}


VertexArray Wall::getWall()
{
        return wall;
}
 

[G.]

wall->wall = lineBottom;

lineBottom c'est un VertexArray*
wall->wall c'est un VertexArray

Donc soit tu utilises pas de pointeur (et tu évites les fuites mémoires)  soit tu le déréférences.

A part ça, quand t'as un probleme ou une erreur, ça serait bien de dire laquelle quoi

[zimzim]

Bon c'est Ok !

Dur la semaine..

Finalement, j'ai tranché pour du :

Mon tableau de Wall (2011)

vector<shared_ptr<Wall>> borders;

 

Wall.h

#pragma once

#include <SFML/Graphics.hpp>
#include "Utility.h"

using namespace std ;
using namespace sf ;

class Wall
{
        public:
                Wall() ;
                Wall(Vertex point1, Vertex point2);
                VertexArray getWall();

        private:
                VertexArray* wall;
};
 

Wall.cpp

#include "Wall.h"

Wall::Wall()
{

}

Wall::Wall(Vertex _point1, Vertex _point2)
{
        Vertex point1 = _point1;
        Vertex point2 = _point2;
        wall = new VertexArray(sf::PrimitiveType::Lines, 2);
        wall->append(point1);
        wall->append(point2);

}


VertexArray Wall::getWall()
{
        return *wall;
}


/* Juste que le truc que j'avais pas compris c'était ça ! =>  *wall; */

 

Mon code dans Game.cpp si jamais.

/* je crée ici */
auto lineTop = std::make_shared<Wall>(Vertex(map->topLeft, Color::White), Vertex(map->topRight, Color::White));
/* j'insére la  */
borders.push_back(lineTop);

/* Et j'affiche :) */
for (auto&& wall : borders)
{
        window->draw(wall->getWall());
}


 

Merci quand même G.
Peut être j'aiderai quelqu'un ... qui sait ?


je pense que j'avais juste envie de parler à des gens :p


Sur ceux bon week-end a tous

@+

[Laurent]

Juste un conseil : bosse un peu plus ton C++. Il y a beaucoup beaucoup de bêtises, plus ou moins graves, dans ton code.