20 Décembre 2019
Attaque :
Pour la fonction Attaque(), nous lançons une boucle qui se répéteras pour chaque case du tableau Tunite_Total (tableau total de toute les unités du jeu) avec pour compteur de boucle U. Cette boucle est nécessaire car la fonction n'est pas placé dans l'instance d'objet Unite pour certaine raison. De plus, nous avons besoin de trois variable : U_Att, la position dans le tableau Tunite_Total de l'attaquant. C_Deff qui va nous permettre de calculer la case ciblé. Et la dernière positionCase, qui est surtout va permettre l'optimisation du Code.
void Attaque(){
for(int U=0; U<Tunite_Total.length; U++){
if(TuniteVivant_Total[U]==true){
if(Tunite_Total[U].Phase_Perso==2){
U_Att=U;
positionCase=Tunite_Total[U].NumCase;
Donc, après notre boucle on a la classique condition servant à savoir si l'unité est vivante. On vérifie que notre unité est bien en phase d'attaque et on affecte la valeur de la position de l'unité dans le tableau Tunite_Total. Pour positionCase, on affecte juste la valeur NumCase de l'unité afin de simplifier et de minimiser le nombre de caractère lors du codage.
Après on passe à la sélection de la case qu'on attaque, et à partir d'ici le code diffère en fonction de la portée de l'unité. Je prend donc l'exemple de la portée la plus simple ( de une case).
if(Tunite_Total[U].portee=="1"){
image(CaseAtt[0],Tunite_Total[U].xperso-taille+1,Tunite_Total[U].yperso+1,Tunite_Total[U].taille-1,Tunite_Total[U].taille-1);
image(CaseAtt[0],Tunite_Total[U].xperso+taille+1,Tunite_Total[U].yperso+1,Tunite_Total[U].taille-1,Tunite_Total[U].taille-1);
image(CaseAtt[0],Tunite_Total[U].xperso+1,Tunite_Total[U].yperso-taille+1,Tunite_Total[U].taille-1,Tunite_Total[U].taille-1);
image(CaseAtt[0],Tunite_Total[U].xperso+1,Tunite_Total[U].yperso+taille+1,Tunite_Total[U].taille-1,Tunite_Total[U].taille-1);
if(mousePressed==true){
if(mouseButton==LEFT){
C_Deff=positionCase+1;
for(int i=0; i<4; i++){
if(C_Deff>=0 && C_Deff<300){
if(Emplacement[C_Deff].Presence!="Vide" && Emplacement[C_Deff].Presence!="Mur"){
if(mouseX>=Emplacement[C_Deff].xposition && mouseX<=Emplacement[C_Deff].xposition+taille && mouseY>=Emplacement[C_Deff].yposition && mouseY<=Emplacement[C_Deff].yposition+taille){
Degat(); } } }
if(C_Deff==positionCase-20) {C_Deff=positionCase+20;}
if(C_Deff==positionCase-1) {C_Deff=positionCase-20;}
if(C_Deff==positionCase+1) {C_Deff=positionCase-1;} } } }
On commence par la première condition, celle vérifiant la portée de l'unité. Après il nous faut afficher sur le terrain les différentes case que le joueur peut attaquer. On affiche donc ici quatre image. Et on passe à la sélection de la case à attaquer par la condition "si la souris est pressée et si la touche pressée est le bouton gauche".
A partir de maintenant, on va utiliser la variable C_deff pour chercher une case dans le tableau Emplacement, comme nous l'avons précédemment fait pour les déplacements des unité, je ne reviendrais donc pas sur ces détails.
On affecte donc C_deff à la variable de la 1er case du terrain à examiner puis on déclare une boucle de longueur égale au nombre de case à examiner. Dans la boucle, on vérifie d'abord la présence de la case afin d'éviter une action inutile. Puis on vérifie les coordonnée de la souris par rapport à la case du terrain afin de savoir si c'est bien cette case qui est sélectionnée. Si les 2 variables sont vérifiés, on déclenche la fonction degat(). Après les deux conditions et la potentiel appel de fonction, on change la valeur de C_deff afin d'examiner une autre case. Pour ce faire on vérifie d'abord la valeur de C_Deff puis on lui attribue une valeur spécifique en conséquence. Attention à l’ordre de ces attributions, il faut que la première case examiner soit en dernière position et la dernière case analyser doit se placer à la première position.
On a donc sélectionne notre case, maintenant on passe l'attribution des dégâts.
void Degat(){
if(U_Att<limite_d_unit && Emplacement[C_Deff].Presence=="Joueur 2"){
for(int U=0; U<Tunite_JII.length; U++){
if(TuniteVivant_JII[U]==true){
if(Tunite_JI[U_Att].Phase_Perso==2){
if(Tunite_JII[U].xperso==Emplacement[C_Deff].xposition && Tunite_JII[U].yperso==Emplacement[C_Deff].yposition){
Degat=int(Tunite_JI[U_Att].att-Tunite_JII[U].def);
if(Degat<=0){
Degat=1;}
Tunite_JII[U].Vie-=Degat;
action=0;
mousePressed=false;
Tunite_JI[U_Att].Phase_Perso=0;
Tunite_JI[U_Att].mouvement=0; } } } } }
Nous avons ici l'exemple pour les unité du Joueur 1.
Donc pour l'attribution de dégâts, il nous faut savoir qui est notre attaquant et qui est la cible. Et c'est à ça que sert notre première condition. Nous regardons si l'unité appartient au Joueur 1 par le biais de la variable U_att définie précédemment, et on vérifie si la présence sur la case attaqué est bien celle d'un ennemie. Si c'est le cas on déclare une boucle pour chaque case du tableau d'unité du Joueur 2 avec la classique condition de si l'unité est vivante. La condition suivante est la même qui a été utilisé lors de la précédente fonction, elle n'est donc pas utile mais je préfère la garder par sécurité (on ne sait jamais). On compare, ensuite, les coordonnée de l'unité avec la case ciblé pour savoir si l'unité est bien celle qui est attaquée. Puis on calcule les dégâts qui est une simple soustraction de la défense de l'unité ciblé sur l'attaque de l'unité attaquante. Pour des raisons de règle, on veut des dégâts entier et toujours supérieur à 0, je rajoute donc une petite condition et une affectation de valeur. On soustrait ensuite les dégâts à la vie de l'unité attaqué. Puis on remet l'unité attaquante en phase inactif et le jeu continue.
Mais il nous faut encore coder la mort de nos unités.
void Mort(){
for(int U=0; U<Tunite_Total.length; U++){
if(TuniteVivant_Total[U]==true){
if(Tunite_Total[U].Vie<=0){
TuniteVivant_Total[U]=false;
if(U<limite_d_unit){
TuniteVivant_JI[U]=false;
}
if(U>=limite_d_unit){
TuniteVivant_JII[U-limite_d_unit]=false; } } } } }
On lance donc une boucle pour chaque unité du jeu, on vérifie leur point de vie et si ce nombre est inférieur ou égale 0,on passe alors (dans le tableau booléen à la case de l'unité) de vrai à faux.