Ce document est une proposition de fichiers à coder. Il n'est pas complet, c'est encore un brouillon et il ne prend pas en compte tous les aspects du programme, mais il pourrait servir à nous mettre d'accord sur la structure de notre programme. Ce qui serait bien c'est que chacun le commente, fasse des propositions, dise ce qui ne va pas ou ce qui marche ou en propose un différent et qu'on puisse se réunir pour en parler. L'objectif étant de produire un document final auquel chacun puisse se référer lorsqu'il nous faudra travailler sur notre partie de code. Au final, le document que nous devrons faire devrait plus ressembler à une documentation listant les fichiers, les structures, les fonctions avec leurs entrées, leurs sorties et leur description.

Personnage.h

Enumération : Caractéristique : PV, PD, Mana, etc (Énumère les caractéristiques possibles pour un personnage)

Structure : Personnage

Char Classe (Le nom de la classe, ex : Guerrier, Mage, etc)

Int caractériquesDepart[] (un tableau d'entier qui représentent les caractéristiques telles que PV,PD, et autres s'il y a)

Int caractéristiquesActuelles[] (Pareil mais qui changent au cours d'une partie. Je ne sais pas si c'est nécessaire)

List Compentences Comp (Le choix d'une liste pour pouvoir faire évoluer facilement le nombre de compétences. Si l'on se fixe un nombre de compétences pour toutes les classes, on pourrait passer en tableau)

Case Position (La position du personnage est représenté par une case)

List Etat etat (On peut ajouter des états actuels tel que paralysie (parce que je l'ai vu dans le code d'Henri) ou encore Poison, SuperVitesse, ou bien d'autre choses selon ce que vous voulez, si c'est quelque chose que vous voulez ajouter. Ce qui serait bien serait aussi serait d'y ajouter un Etat « Mort » pour retirer le personnage de la partie. La question étant : vaut il mieux une liste d'entiers définie par une énumération des états possible et des fonctions déterminants les effets qui leur sont associé ou une classe Etat dont les attributs déterminent les effets possible (exemples : un entier déterminant une perte de PV, un Booléen déterminant si le personnage est capable ou non d'effectuer des actions, etc) et des fonctions génériques permettant de les appliquer ?)

Apparence ? (Je ne sais pas encore comment nous allons faire le lien avec l'interface graphique, mais pour représenter le personnage, on pourrait peut être mettre dans la structure l'apparence qui lui est associé, ou ses animations, ou que sais je. Je ne sais pas encore bien commence ça fonctionne).

Fonctions associées :

CréerPers : Crée un personnage sans caractéristiques, classe, etc.

InitialiserPers : Initialise les attributs d'un personnage (avec en entrée un fichier txt ? Une BDD?)

SetPers : crée un personnage avec attributs.

Get : Un lot de getters pour obtenir les différents attributs du personnage.

ChangerCaracAct : change une caractéristique actuelle

ChangerCaracDep : change une caractéristique de départ

AjouterEtat : ajoute un état a la liste d'états

VerifierEtat : Renvoie 1 si l'état est dans la liste des états

SupprimmerEtat : supprime un état de la liste.

AjouterComp : ajoute une compétence à la liste de compétences

SupprimmerComp : supprimme une compétence de la liste.

ChangerPosition : Modifier la position du personnage.

Equipe .h

Structure : Equipe

Char Name (Un nom pour identifier l'équipe (un joueur peut-il avoir avoir plusieurs équipes différentes ? Pour faire des choix de technologie différents par exemple))

Personnage All[] (définit tous les personnages d'une équipe, en fait se sont toutes les classes disponibles.)

Personnage EquipeActuelle[] (Un tableau de personnage pour définir les personnages qui prendront part à la partie.)

Tree Technologie techno (L'arbre des compétences que possède l'équipe et qui restent à débloquer. Il faut aussi déterminer une structure Technologie qui aurait par exemple comme attributs un booléen « obtenue », le nombre d'xp nécessaire, le bonus accordé, je ne sais pas exactement ce que vous voulez y mettre).

Int xp (le niveau d'expérience de l'équipe)

Int PC (Je ne sais pas si vous souhaiter faire un système d'achat de technologie par expérience ou par point de compétences, mais nous pourrions stocker ici le nombre de points de compétences à allouer aux technologies)

Fonctions associées :

CréerEq : Crée une équipe sans valeurs pour ces attributs

InitialiserEq : Initialise les attributs d'une équipe (avec en entrée un fichier txt ? Une BDD?)

SetEq : crée une équipe avec attributs.

ChoisirPers : Le personnage est ajouté à l'équipe actuelle

RetirerPers : Le personnage est retiré de l'équipe actuelle

SauverEq : La configuration actuelle de l'équipe (nom, xp, technos, etc) est sauvée (dans un fichier txt ? Une BDD ?).

Case.h

Énumération Terrain : Plaine, Foret, etc.

Structure Case

int x

int y (ce sont les coordonnées de la case)

Terrain type : Le type de la case

List Case casesAdjacentes/Atteignables (Une liste des cases adjacentes, je ne sais pas si cela nous sera utile. Sinon une liste des case atteignables depuis cette case par un déplacement ou une compétence qui s'actualise quand on sélectionne une action.)

Boolean Occupée (Représente si la case est occupée ou non par un personnage)

Fonctions associées :

Créer : Crée une case sans valeurs pour ces attributs

Initialiser : Initialise les attributs d'une case

Set : crée une case avec attributs

Get : un lot de getters pour obtenir les coordonnées de la case.

ActualiserAtteignables : Actualise les cases atteignables par une compétence

ChangerType : change le type de terrain (Je ne sais pas si se sera utile)

estOccupée

OccupéePar : renvoie le personnage occupant la case.

est «Terrain » : Renvoie 1 si la case est bien du type « Terrain » (Il y a bien une fonction par type de terrain. On pourrait également faire un getType qui renvoie l'entier associé au type de terrain.)

Carte.h

Structure Carte

Char NomCarte (Le nom de la carte (pour pouvoir la sélectionner parmi plusieurs par exemple)

Case Carte[][] (un tableau de cases à deux entrées qui contient les cases de la carte).

Fonctions associées :

Créer : Crée une carte sans valeurs pour ces attributs

Initialiser : Initialise les attributs d'une carte.

GetNom : Obtenir le nom de la carte

Set : crée une carte avec attributs (depuis un fichier txt ou une BDD?)

ChangerNom : change le nom de la carte.

Sauver : Crée une sauvegarde de la carte.

Action.h

Énumération Effet : Dégâts, déplacement, etc

Structure Compétence

Char Nom (le nom de la compétence)

Int portée (la portée de la compétence en nombre de cases)

Int zone (la portée de la zone en nombre de cases à partir de la case affectée, si l'on décide éventuellement de faire des compétences affectant des zones)

List int effet (la liste des effets provoqués par la compétence, par exemple, dégâts, déplacement, changement d'état, etc)

int caractéristiquesRequises[] (un tableau réunissant les caractéristiques requises par la compétences, par exemple les PV, PD, Mana, etc.)

Fonctions associées :

Créer : Crée une compétence sans valeurs pour ces attributs

Initialiser : Initialise les attributs d'une compétence (depuis un fichier txt ou une BDD?)

Get : un lot de getters pour les attributs

Set : crée une compétence avec attributs (depuis un fichier txt ou une BDD?)

LancerCompétence : Lance la compétence d'un personnage vers une case.

Evaluer « Effets » : Pour chaque effet, une fonction qui détermine les changements à effectuer sur les attributs des personnages.

CaseAffectée : Renvoie la liste de cases à portée de la compétence.

estLançable : Fonction qui détermine si la fonction est lançable (en fonction de sa portée, des caractéristiques du personnage, etc. Cette fonction doit utiliser un lot de fonction testant les caractéristiques du personnage)

Commentaires :

Il reste également à déterminer des fichiers contrôlant le déroulement d'une partie. Je pensais à un fichier Partie contenant structure Joueur et un structure Partie. Le joueur étant composé d'un nom, d'une équipe et d'un booléen déterminant si c'est à son tour ou non. La partie d'une liste de joueur, d'un nombre de tours actuel, d'une carte. Les fonctions importantes pourraient être : fin de tour, fin de partie, joueur suivant.

Je remarque aussi qu'il faudrait certainement faire une structure classe et une structure personnage et une structure classes distinctes comme ce qui a été commencé dans le code. En effet sinon on ne peut pas différencier les personnages d'une même classe de deux joueurs différents.

Colin Drieu

2016-02-28T14:00:35