Bonjour à tous, 

j'ai une variable initialisée dans mon int main(), il s'agit d'un tableau correspondant à un tile mapping (le tableau est donc la map)

D'autre part j'ai crée une classe Personnage, qui va posséder des attributs de position et une méthode qui déplace le personnage en modifiant la position

Toute fois, le déplacement dépend du tableau qui représente la map, et j'ai donc besoin de cette variable au sein de ma classe. Comment puis-je y accéder au sein d'une méthode ? Je pensais à créer un attribut map au sein de la classe personnage et d'entrer le tableau dans le constructeur du personnage mais ça risque d'être un peu lourd

Auriez vous une autre idée ?

Merci bien

Salut,

Sans avoir un minimum du code que tu as déjà produit, il nous sera particulièrement difficile de t'aider.

Cependant, la règle est d'essayer, pour chaque notion qui apparait dans ton étude des besoins (ou dans ton analyse fonctionnelle, si tu veux) d'avoir une notion équivalente dans ton code, qui fournira les services dont tu estimes avoir besoin.

De même, le principe connu sous le terme de SRP (Single Responsability Principle ou "principe de la responsabilité unique") nous indique que chaque notion (chaque type de donnée, chaque donnée, chaque fonction) ne devrait s'occuper que d'une seule chose de manière à pouvoir s'en occuper correctement.

Ainsi, tu nous parle de "tile mapping", ce qui correspond à la notion de "plateau de jeu". La première question que tu devrais donc te poser est: Quelle responsabilité (unique !!) vais-je donner à mon plateau de jeu?

La réponse à cette question pourrait être proche de

Le "plateau de jeu" va maintenir en mémoire une représentation de l'ensemble du terrain -- à un instant T -- sur lequel mes personnages pourront évoluer

Notes au passage qu'il n'y a aucune notion de donnée graphique ici: on veut juste savoir que la case qui se trouve en (4,5) "contient" un obstacle (un rocher, une marre, un mur, ...) que la case qui se trouve en (5,7) "contient" un troll et que la case qui se trouve en (9,15) "contient" notre personnage.  La manière dont on représentera les différentes cases pour faire plaisir au joueur n'intervient absolument pas ici. 

Je pourrais donc donner une représentation possible des données de mon plateau de jeu sous une forme proche de

|---+---+---+---+---|
| E | E | E | Wa| H |
+---+---+---+---+---|
| W | W | E | E | E |
|---+---+---+---+---|
| T | Tr| E | E | E |
|---+---+---+---+---|
| E | E | E | E | E |
|---+---+---+---+---|
| D | E | Wa| Wa| E |
|---+---+---+---+---|
| E | E | Wa| Wa| E |
|---+---+---+---+---|
LEGEND:
E  : Empty
Wa : Water
W  : Wall
T  : Tree
Tr : Troll
D  : Dragon
H  : Hero

(bien sur, ton propre plateau de jeu pourra être bien plus étendu que cela )

Mais cette représentation n'est qu'une des formes que je pourrais donner à mon plateau. 

Mais, à partir du moment où j'aurai déterminé la responsabilité de mon plateau de jeu, je peux commencer à m'intéresser au services que je suis sans doute en droit d'attendre de sa part.

Il est possible d'attendre deux grands types de services de la part d'une classe ou d'une struture:

• on peut l'interroger sur un état particulier et
• on peut lui donner un ordre pour faire changer un de ses états

Les principales questions que nous voudrons sans doute lui poser seront sans doute:

• Où se trouve mon héros?
• Qu'est ce qui se trouve sur la case (X, Y) ?
• Mon héros peut-il se déplacer (dans Telle direction) ?
• (de manière plus générale) ce qui se trouve (à tel endroit) peut il se déplacer (dans telle direction)?
• Quelle est ta hauteur (en nombre de cases) ?
• Quelle est ta largeur (en nombre de cases) ?

Et les principaux ordres que je voudrais pouvoir lui donner seront sans doute :

• déplace mon héros ( dans telle direction)
• déplace ce qui se trouve (à tel endroit, dans telle direction)
• (au début de la partie) charge les données depuis (tel fichier)

Et je n'aurai pas besoin de plus... Du moins, pour représenter mon plateau de jeu.

Par contre, tu auras remarqué que, dans la représentation (très personnelle) que je t'ai donnée de mon plateau de jeu, j'ai utilisé des symboles particuliers, pour lesquels j'ai été jusqu'à dresser une légende.  Ces symboles représentent la notion de "contenu du plateau". Et c'est donc une notion qui devra apparaître dans mon code.

Le plus efficace est sans doute d'utiliser une énumération, de manière à ce que chaque term utilisé soit associé à une valeur numérique bien particulière (cela facilitera les différents tests que nous devrons effectuer).  Je vais donc créer une énumération proche de

enum PlateContent{
    Empty,
    Hero,
    Wood,
    Water,
    Wall,
    Rock,
    Troll,
    Dragon,
    /* ... */
    MAX // cela peut être intéressant pour certaines situations 
};

De même, les services dont je veux profiter ont mis en évidence que j'aurai besoin de la notion de direction. je vais donc fournir une autre énumération qui représentera cette notion sous une forme proche de

enum Direction{
    up,
    down,
    left,
    right
};

Mais j'aurai aussi besoin de la notion de "position".  Je devrai donc la représenter dans le code sous une forme particulière.  Elle prendra sans doute la forme de

struct Position{
    size_t x; // la coordonnée sur l'axe des X
    size_t y; // la coordonnée sur l'axe des Y
};

Et, tant qu'à faire, nous pourrions sans doute définir la notion de "déplacement" comme étant le fait de quitter une position donnée dans une direction donnée, ce qui pourrait ressembler à

struct Move{
    Position start;
    Direction direction;
};

class Plate{
public:
    /* les services que je suis en droit d'attendre de sa part */
    /* d'abord les questions que je veux lui poser */
    Position const & whereIsHero() const;
    bool heroCanMove(Direction dir) const;
    PlateContent whatsOn(Position const & pos) const;
    bool canMove(Move const & move) const;
    size_t width() const;
    size_T height() const;
    /* puis les ordre que je veux pouvoir lui donner */
    /* le déplacement du héros me dit ce qu'il rencontre
     * sur la case sur laquelle il arrive
     */
    PlateContent moveHero(Direction direction);
    /* quand je déplace "quelque chose", je veux savoir
     * ce qui se trouve sur la case de destination
     */
    PlateContent move(Move const & theMove);
    void loadFromFile(std::string const & filename);
private:
    /* Les données qui seront utiles pour tous ces services */
    size_t width_; // la hauteur du plateau
    size_t height_; // la largeur du plateau
    std::vector<PlateContent> plate_; // toutes lss cases du plateau;
    size_t hero_; // la position du héros (sous forme d'indice dans
                  // le tableau
    /* une fonction interne de conversion position-->index */
    size_t toIndex(Position const & pos) const{
        return pos.y * height_ + pos.x;
    }
    /* une version interne de conversion index-->position */
    Position toPosition(size_t index) const{
        Position p;
        p.y = index / height_;
        p.x = index % height_;
        return p;
    }
};

Avec une telle classe, tu devrais avoir "tout ce qu'il te faut" pour pouvoir travailler à ton aise

NOTA: il est impératif d'essayer de séparer clairement les différents besoins : l'affichage que tu offres au joueur ne doit s'occuper que de ... donnée une vue "excitante" au joueur, et ne doit pas s'inquiéter de manipuler la position des différents éléments.  Il devra "uniquement" s'occuper de convertir la position des différents éléments (obtenu de la part de la classe Plate) et de les convertir en positions auxquelles placer les différents "sprites" que tu voudras utiliser

-
Edité par koala01 26 août 2018 à 17:17:57