Bonsoir. Je suis face à un problème en php, que j'ai simplifié :

deux variables différentes, w et z
une boucle
à chaque boucle, w et z sont diminués de 1
dès qu'une des deux variables devient inférieure ou égale à 0, la boucle s'arrête

J'ai d'abord pensé à faire une boucle avec OR, w > 0 OR z > 0. Logique. Mais ça ne marche pas.

$w = 4 ;
$z = 3 ;

while (($w > 0) OR ($z > 0) )
{

echo "w et z ont été diminués de 1 pour obtenir respectivement " ;
$w = $w - 1 ;
$z = $z - 1 ;
echo $w." et ".$z.". <br>" ;
}

Résultat obtenu :

w et z ont été diminués de 1 pour obtenir respectivement 3 et 2.
w et z ont été diminués de 1 pour obtenir respectivement 2 et 1.
w et z ont été diminués de 1 pour obtenir respectivement 1 et 0.
w et z ont été diminués de 1 pour obtenir respectivement 0 et -1. problème ici, on a un -1 après 0 alors que la boucle aurait du s'arrêter

Puis, après de multiples tests, je me décide contre toute logique à tester avec AND, w > 0 AND z > 0. Illogique, mais ça marche.

$w = 4 ;
$z = 3 ;

while (($w > 0) AND ($z > 0) )
{

echo "w et z ont été diminués de 1 pour obtenir respectivement " ;
$w = $w - 1 ;
$z = $z - 1 ;
echo $w." et ".$z.". <br>" ;
}

Le résultat qui marche :
w et z ont été diminués de 1 pour obtenir respectivement 3 et 2.
w et z ont été diminués de 1 pour obtenir respectivement 2 et 1.
w et z ont été diminués de 1 pour obtenir respectivement 1 et 0.

Et je ne comprend absolument pas. Avec OR dans while, normalement ça doit vouloir dire "dès qu'une des deux variables passe à 0, la boucle s'arrête, donc on n'a pas le temps d'avoir une valeur à -1"
En revanche avec AND dans while, normalement il faudrait que les deux variables passent par 0 avant que la boucle s'arrête, ce qui impliquerait d'avoir nécessairement une variable en négatif avant l'arrêt de la boucle, si w=/=z

Et j'observe l'inverse, je ne comprends absolument pas pourquoi

Si on pouvait m'éclairer.

Avec OR dans while, normalement ça doit vouloir dire "dès qu'une des deux variables passe à 0, la boucle s'arrête, donc on n'a pas le temps d'avoir une valeur à -1"

Hein?

while (($w > 0) OR ($z > 0) ) veut dire: tant que w > 0 OU QUE z > 0, alors on continue.

"En revanche avec AND dans while, normalement il faudrait que les deux variables passent par 0 avant que la boucle s'arrête"

Heu non

while (($w > 0) AND ($z > 0) ) veut dire: "On ne continue que si w > 0 ET QUE z > 0." si w=1 et z=0, on arrête. Niveau premier cours d'algorithmique

En faite tu confonds carrément AND et OR

Tu es autodidacte je suppose? Il faudrait peut-être songer à voir des cours d'algorithmique avant de coder.

Même si tu comptes te contenter d'un niveau amateur, il y a des bases fondamentales à avoir.

Dans ton cas tu aurais aussi besoin de quelques cours d'algèbre booléenne:

0 OR 1 = 1
0 AND 1 = 0

D'accord, j'ai compris. C'est -Troll qui a raison effectivement. Mais merci à inhert pour ces éclaircissements.

En fait je pensais que while faisait mécaniquement une boucle, sans trop y réfléchir. Je ne suis pas un programmeur, effectivement, je cherchais juste à bricoler un peu.

Merci à vous !

(le problème n'est pas au niveau algorithmique, je ne suis pas un abruti hein, c'est plus une étourderie.)

J'ai eu peur, tu me rassures.

C'est qu'on voit de tout sur ce site.

aucun rapport

Mais tu devrais faire :
Tant que x ou y supérieur OU EGALE à 0 : Alors =>

Parce'que là tu lui demande un strict inférieur, c'est normal qu'il te donne -1.
Donc : while(x >= 0) {
}

Enfin bref. Je suppose que ça marche

Autre solution que je viens de penser :

x = 5;
while(x != 0){ echo "Salut !"; x--; }

Tant que x n'est pas égal à 0.

Justement. J'arrive pas avec ces formulations bizarres. "while(x != 0){ echo "Salut !"; x--; } "
Avec des $x++ et trucmuche. Je trouve pas ça concret, j'ai besoin de que les choses soient carrées, instinctives.

Tu l'auras compris, tous les codes que je fais sont très, très mal optimisés, voire moches. Mais à la limite, je m'en fous tant que ça marche.

Dernier exemple en date. Je préviens, c'est très, très laid.
Mais ça marche

<?php

// Avant toute chose, vu que des fonctions erreurs fatales sont présentes sur la page on précise le mél de l'admin
$mel_admin = "fgdfgdfghdfhdf@gmail.com" ;

/*
On considère la flotte comme empaquetée dans la base de donnée.
Par comodité, pour le moment, il n'y a pas de base de donnée.
Elle est simulée via des variables au début du script.

• /

//Début du message d'erreur
echo "<fieldset><legend>Erreur</legend>Pas de connexion à la base de données. Les variables
ont été générées manuellement dans le script php
<br><br>
<span style=font-family: comic sans ms,sans-serif; title='pv_att
pv_def
ratio_pv_att
ratio_pv_def
pvcrit_att
pvcrit_def
ratio_pvcrit_att
ratio_pvcrit_def
sigma_boubou_att
sigma_boubou_def
abs_boubou_att
abs_boubou_def
pv_att_ori
pv_def_ori
pvcrit_att_ori
pvcrit_def_ori
n_round
pui_att
pui_def
'><span style='font-size: 10pt;border-bottom: 1px black dotted;'>
Liste des variables attribuées pour chaque type de vaisseaux (ici scout et destroyers)
</span></span>
</fieldset>" ;

// Fin du message d'erreur

// Assignation des variables (à défaut d'une connexion à la BDD)
$group_scout_att = 1 ; // on annonce la présence des groupes (1=présent/0=absent), ce sera utile
$group_destroy_att = 1 ; // pour la détermination de l'aggro lors de la boucle de combat

$group_scout_def = 1 ; // idem
$group_destroy_def = 1 ;

// Pour la boucle principale, on va définir des variables destinées à savoir s'il y a encore des groupes en jeu
// dans la bataille :
$sigma_group_att = $group_scout_att + $group_destroy_att ;
$sigma_group_def = $group_scout_def + $group_destroy_def ;

$n_scout_att = 20 ;
$n_scout_def = 20 ;
$scout_pv_att_ori = 1000 ;
$scout_pv_def_ori = 750 ;
$scout_pvcrit_att_ori = 100 ;
$scout_pvcrit_def_ori = 100 ;
$scout_pv_att = 1000 ;
$scout_pv_def = 750 ;
$scout_pvcrit_att = 100 ;
$scout_pvcrit_def = 100 ;
$scout_sigma_boubou_att = 500 ;
$scout_sigma_boubou_def = 500 ;
$scout_abs_boubou_att = 0.9 ; // =10% (donc multiplateur 1-0.1=0.9)
$scout_abs_boubou_def = 0.85 ; // =15% (donc multiplicateur 1-0.15=0.85)
$scout_n_round = 1 ;
$scout_pui_att = 25 ;
$scout_pui_def = 25 ;

$n_destroy_att = 10 ;
$n_destroy_def = 10 ;
$destroy_pv_att_ori = 3000 ;
$destroy_pv_def_ori = 1000 ;
$destroy_pvcrit_att_ori = 100 ;
$destroy_pvcrit_def_ori = 100 ;
$destroy_pv_att = 3000 ;
$destroy_pv_def = 1000 ;
$destroy_pvcrit_att = 100 ;
$destroy_pvcrit_def = 100 ;
$destroy_sigma_boubou_att = 750 ;
$destroy_sigma_boubou_def = 750 ;
$destroy_abs_boubou_att = 0.9 ; // =10% (donc multiplateur 1-0.1=0.9)
$destroy_abs_boubou_def = 0.85 ; // =15% (donc multiplicateur 1-0.15=0.85)
$destroy_n_round = 1 ;
$destroy_pui_att = 40 ;
$destroy_pui_def = 40 ;

$n_vx_tot_att = $n_scout_att + $n_destroy_att ;
$n_vx_tot_def = $n_scout_def + $n_destroy_def ;

// Fonction pour la vérification de la division par zero. Je la mets ici car elle ne doit être déclarée qu'une seule
// fois. Si je fous ça dans la boucle, ça renvoie une erreur car la fonction se déclare à chaque tour de boucle

function verif_div_zero ($x, $y)
{
if ($y > 0)
{
return $x / $y ;
}
elseif ($y ==0)
{
return 0 ;
}
else
{
return die('Erreur fatale n°2') ;
}
}

function verif_div_zero_per_cent ($x, $y) // pour les calculs de pourcentages (exemple : capacité des boubous
{
if ($y > 0)
{
return ($x * 100) / $y ;
}
elseif ($y ==0)
{
return 0 ;
}
else
{
return die('Erreur fatale n°2') ;
}
}

/*

>>>>>>>> <<<<<<<<<<<<<

>>>>>>>> LE SCRIPT EST DIVISE EN PLUSIEURS BOUCLES POUR CHAQUE TYPE DE VAISSEAUX <<<<<<<<<<<<<

>>>>>>>> <<<<<<<<<<<<<

• /

// Début du script
// Boucle

$n_round = 0 ;
while ($sigma_group_att > 0 AND $sigma_group_def > 0 )
{ /*s'il y a encore des groupes dans la bataille,
continuer boucle */

// Pour le calcul des ratios, on évite la division par zero...

$x = $scout_pv_att ;
$y = $scout_pv_att_ori ;
$scout_ratio_pv_att = verif_div_zero($x,$y) ;
$scout_ratio_pv_att = number_format($scout_ratio_pv_att,3); // on arrondit à chaque fois à 3 chiffres après la
// virgule (le maximum de sensibilité nécessaire

$x = $scout_pv_def ;
$y = $scout_pv_def_ori ;
$scout_ratio_pv_def = verif_div_zero($x,$y) ;
$scout_ratio_pv_def = number_format($scout_ratio_pv_def,3);

$x = $scout_pvcrit_att ;
$y = $scout_pvcrit_att_ori ;
$scout_ratio_pvcrit_att = verif_div_zero($x,$y) ;
$scout_ratio_pvcrit_att = number_format($scout_ratio_pvcrit_att,3);

$x = $scout_pvcrit_def ;
$y = $scout_pvcrit_def_ori ;
$scout_ratio_pvcrit_def = verif_div_zero($x,$y) ;
$scout_ratio_pvcrit_def = number_format($scout_ratio_pvcrit_def,3);

$x = $destroy_pv_att ;
$y = $destroy_pv_att_ori ;
$destroy_ratio_pv_att = verif_div_zero($x,$y) ;
$destroy_ratio_pv_att = number_format($destroy_ratio_pv_att,3);

$x = $destroy_pv_def ;
$y = $destroy_pv_def_ori ;
$destroy_ratio_pv_def = verif_div_zero($x,$y) ;
$destroy_ratio_pv_def = number_format($destroy_ratio_pv_def,3);

$x = $destroy_pvcrit_att ;
$y = $destroy_pvcrit_att_ori ;
$destroy_ratio_pvcrit_att = verif_div_zero($x,$y) ;
$destroy_ratio_pvcrit_att = number_format($destroy_ratio_pvcrit_att,3);

$x = $destroy_pvcrit_def ;
$y = $destroy_pvcrit_def_ori ;
$destroy_ratio_pvcrit_def = verif_div_zero($x,$y) ;
$destroy_ratio_pvcrit_def = number_format($destroy_ratio_pvcrit_def,3);

/*
A virer (ancien système avant la fonction div par zero pour le calcul des ratios

$destroy_ratio_pv_att = $destroy_pv_att / $destroy_pv_att_ori ;
$destroy_ratio_pv_att = number_format($destroy_ratio_pv_att,3); // idem (pour l'arrondi)
$destroy_ratio_pv_def = $destroy_pv_def / $destroy_pv_def_ori ;
$destroy_ratio_pv_def = number_format($destroy_ratio_pv_def,3);
$destroy_ratio_pvcrit_att = $destroy_pvcrit_att / $destroy_pvcrit_att_ori ;
$destroy_ratio_pvcrit_att = number_format($destroy_ratio_pvcrit_att,3);
$destroy_ratio_pvcrit_def = $destroy_pvcrit_def / $destroy_pvcrit_def_ori ;
$destroy_ratio_pvcrit_def = number_format($destroy_ratio_pvcrit_def,3);

• /

// fin de la vérification de la division par zero et du calcul des ratios

echo "<br><br>";

echo "<div align=center>
<table border=1>
<CAPTION>Rapport de combat round n°".$n_round." pour les scouts</caption>
<tr>
<th>Composantes</th>
<th>Flotte assaillante</th>
<th>Flotte défensive</th>
</tr>
<tr>
<th>Nombre</th>
<td>".$n_scout_att."</td>
<td>".$n_scout_def."</td>
</tr>
<tr>
<th>PV</th>
<td>".$scout_pv_att."</td>
<td>".$scout_pv_def."</td>
</tr>
<tr>
<th>Ratio PV</th>
<td>".$scout_ratio_pv_att."</td>
<td>".$scout_ratio_pv_def."</td>
</tr>
<tr>
<th>PV critiques</th>
<td>".$scout_pvcrit_att."</td>
<td>".$scout_pvcrit_def."</td>
</tr>
<tr>
<th>Ratio PV critiques</th>
<td>".$scout_ratio_pvcrit_att."</td>
<td>".$scout_ratio_pvcrit_def."</td>
</tr>
<tr>
<th>Sigma bouclier</th>
<td>".$scout_sigma_boubou_att."</td>
<td>".$scout_sigma_boubou_def."</td>
</tr>
<tr>
<th>Abs bouclier</th>
<td>".$scout_abs_boubou_att."</td>
<td>".$scout_abs_boubou_def."</td>
</tr>

</table></div>

<div align=center>
<table border=1>
<CAPTION>Rapport de combat round n°".$n_round." pour les destroyers</caption>
<tr>
<th>Composantes</th>
<th>Flotte assaillante</th>
<th>Flotte défensive</th>
</tr>
<tr>
<th>Nombre</th>
<td>".$n_destroy_att."</td>
<td>".$n_destroy_def."</td>
</tr>
<tr>
<th>PV</th>
<td>".$destroy_pv_att."</td>
<td>".$destroy_pv_def."</td>
</tr>
<tr>
<th>Ratio PV</th>
<td>".$destroy_ratio_pv_att."</td>
<td>".$destroy_ratio_pv_def."</td>
</tr>
<tr>
<th>PV critiques</th>
<td>".$destroy_pvcrit_att."</td>
<td>".$destroy_pvcrit_def."</td>
</tr>
<tr>
<th>Ratio PV critiques</th>
<td>".$destroy_ratio_pvcrit_att."</td>
<td>".$destroy_ratio_pvcrit_def."</td>
</tr>
<tr>
<th>Sigma bouclier</th>
<td>".$destroy_sigma_boubou_att."</td>
<td>".$destroy_sigma_boubou_def."</td>
</tr>
<tr>
<th>Abs bouclier</th>
<td>".$destroy_abs_boubou_att."</td>
<td>".$destroy_abs_boubou_def."</td>
</tr>

</table></div>

" ;

// >>>> Attaque simple
// Répartition des dégats dans chaque groupe
$deg_tot_att = $scout_pui_att + $destroy_pui_att ; // on détermine tout d'abord les dégats totaux
$deg_tot_def = $scout_pui_def + $destroy_pui_def ; // qui seront ensuite répartis selon les vaisseaux
$deg_tot_att_ori = $deg_tot_att ; // on fait une ori pour comparer entre dégats distribués et dégats
$deg_tot_def_ori = $deg_tot_def ; // au tout début
echo "Dégats totaux offensifs ".$deg_tot_att." et défensifs ".$deg_tot_def.". <br>" ;
// Boucle de dégats à répartir selon l'aggro
// Initialisation des dégats subis selon les vaisseaux
$deg_scout_att = 0 ; // évidement, c'est zéro au début !
$deg_scout_def = 0 ;

$deg_destroy_att = 0 ;
$deg_destroy_def = 0 ;

// Pour la flotte offensive
while ($deg_tot_def > 0)
{
if ($group_scout_att == 1)
{
$deg_scout_att = $deg_scout_att + 0.01 * $deg_tot_def ;
$deg_scout_att = ceil($deg_scout_att) ; // on arrondi à l'entier supérieur
echo "<p>[A]Scouts : dégats ".$deg_scout_att." subis.</p>" ;
}
else
{
}

if ($group_destroy_att == 1)
{
$deg_destroy_att = $deg_destroy_att + 0.04 * $deg_tot_def ;
$deg_destroy_att = ceil($deg_destroy_att) ; // on arrondi à l'entier supérieur
echo "<p>[A]Destroyers : dégats ".$deg_destroy_att." subis.</p>" ;
}
else
{
}
echo "<p> [A]Total : sur les ".$deg_tot_def." points de dégats subis, il en reste " ;
$deg_tot_def = $deg_tot_def_ori - ( $deg_scout_att + $deg_destroy_att ) ;
/*
Dégats totaux subis par la flotte offensive est égale aux dégats totaux de la flotte défensive moins les
dégats subis de la flotte offensive
*/
echo $deg_tot_def.".</p>" ;
}

// Pour la flotte défensive
while ($deg_tot_att > 0)
{
if ($group_scout_def == 1)
{
$deg_scout_def = $deg_scout_def + 0.01 * $deg_tot_att ;
$deg_scout_def = ceil($deg_scout_def) ; // on arrondi à l'entier supérieur
echo "<p>[D]Scouts : dégats ".$deg_scout_def." subis.</p>" ;
}
else
{
}

if ($group_destroy_def == 1)
{
$deg_destroy_def = $deg_destroy_def + 0.04 * $deg_tot_att ;
$deg_destroy_def = ceil($deg_destroy_def) ; // on arrondi à l'entier supérieur
echo "<p>[D]Destroyers : dégats ".$deg_destroy_def." subis.</p>" ;
}
else
{
}

echo "<p> [D]Total : sur les ".$deg_tot_att." points de dégats subis, il en reste " ;
$deg_tot_att = $deg_tot_att_ori - ( $deg_scout_def + $deg_destroy_def ) ;
echo $deg_tot_att.".</p>" ;
}

// C'est ici que peuvent intervenir les autres composantes (endomagement des vaisseaux, boucliers, etc)

// Prise en compte des dégats pour chaque groupe AVEC PRISE EN COMPTE de l'absorbance éventuelle boubous
// Avant chaque prise en compte de dégats, on regarde s'il reste une valeur de sigma bouclier suffisante

// En premier lieu, on tient en compte le bouclier absorbeur. C'est la
// valeur obtenue qui sera confrontée aux boucliers sigma.

/* [A]SCOUT : script boubou
Dégats bruts = dégats après prise en compte des boubou abs mais pas des boubou sigma
*/
$deg_brut_scout_att = $deg_scout_att * $scout_abs_boubou_att ;
$deg_scout_att_abs = $deg_scout_att - ( $deg_scout_att * $scout_abs_boubou_att ) ;

if ($deg_brut_scout_att <= $scout_sigma_boubou_att)
{
$percent_ori = $scout_sigma_boubou_att ; // pour le calcul du %, on a besoin d'une valeur d'origine
$scout_sigma_boubou_att = $scout_sigma_boubou_att - $deg_brut_scout_att ; /* on enlève du sigma boubou
la valeur correspondante */

$x = $scout_sigma_boubou_att ;
$y = $percent_ori ;
$percent = verif_div_zero_per_cent ($x, $y) ; // calcul du % de boubou restant (via la fonction donnée précédement)
$percent = number_format($percent,2) ; // on arrondit le pourcentage pour faire joli

echo "<p>Les [A]Scout subissent ".$deg_scout_att." de dégats bruts. Les boucliers
absorbent ".$deg_scout_att_abs." de ces dégats. Les boucliers sigma
absorbent ".$deg_brut_scout_att." points de dégats.
Leur valeur est réduite de ce nombre. Les boucliers sigma tombent à <i>".$percent."%</i> de leurs capacités.</p>" ;

}
elseif ($deg_brut_scout_att > $scout_sigma_boubou_att)
{
$deg_brut_scout_att = $deg_brut_scout_att - $scout_sigma_boubou_att ; // Tout d'abord on décompte du reste des boucliers
$scout_sigma_boubou_att = 0 ; // le boubou sigma passe donc à 0
$scout_pv_att = $scout_pv_att - $deg_brut_scout_att ; // les dégats s'attaquent direct au vaisseau
echo "<p>Les boucliers sigma des [A]Scouts sont saturés ! La flotte attaquante leur inflige
".$deg_scout_att." points de dégats. Ils subissent à l'arrivée ".$deg_brut_scout_att."
points de dégats.</p>";
}
else
{
echo "<p> Erreur fatale n°1. Arrêt du script. Contactez l'administrateur :".$mel_admin.".</p>" ;
Die () ;
}

/* [D]SCOUT : script boubou */
$deg_brut_scout_def = $deg_scout_def * $scout_abs_boubou_def ;
$deg_scout_def_abs = $deg_scout_def - ( $deg_scout_def * $scout_abs_boubou_def ) ;

if ($deg_brut_scout_def <= $scout_sigma_boubou_def)
{
$percent_ori = $scout_sigma_boubou_def ; // pour le calcul du %, on a besoin d'une valeur d'origine
$scout_sigma_boubou_def = $scout_sigma_boubou_def - $deg_brut_scout_def ; /* on enlève du sigma boubou
la valeur correspondante */

$x = $scout_sigma_boubou_def ;
$y = $percent_ori ;
$percent = verif_div_zero_per_cent ($x, $y) ; // calcul du % de boubou restant (via la fonction donnée précédement)
$percent = number_format($percent,2) ; // on arrondit le pourcentage pour faire joli

echo "<p>Les [D]Scout subissent ".$deg_scout_def." de dégats bruts. Les boucliers
absorbent ".$deg_scout_def_abs." de ces dégats. Les boucliers sigma
absorbent ".$deg_brut_scout_def." points de dégats.
Leur valeur est réduite de ce nombre. Les boucliers sigma tombent à <i>".$percent."%</i> de leurs capacités.</p>" ;

}
elseif ($deg_brut_scout_def > $scout_sigma_boubou_def)
{
$deg_brut_scout_def = $deg_brut_scout_def - $scout_sigma_boubou_def ; // Tout d'abord on décompte du reste des boucliers
$scout_sigma_boubou_def = 0 ; // le boubou sigma passe donc à 0
$scout_pv_def = $scout_pv_def - $deg_brut_scout_def ; // les dégats s'attaquent direct au vaisseau
echo "<p>Les boucliers sigma des [D]Scouts sont saturés ! La flotte attaquante leur inflige
".$deg_scout_def." points de dégats. Ils subissent à l'arrivée ".$deg_brut_scout_def."
points de dégats.</p>";
}
else
{
echo "<p> Erreur fatale n°1. Arrêt du script. Contactez l'administrateur :".$mel_admin.".</p>" ;
Die () ;
}

/* [A]DESTROYERS : script boubou */
$deg_brut_destroy_att = $deg_destroy_att * $destroy_abs_boubou_att ;
$deg_destroy_att_abs = $deg_destroy_att - ( $deg_destroy_att * $destroy_abs_boubou_att ) ;

if ($deg_brut_destroy_att <= $destroy_sigma_boubou_att)
{
$percent_ori = $destroy_sigma_boubou_att ; // pour le calcul du %, on a besoin d'une valeur d'origine
$destroy_sigma_boubou_att = $destroy_sigma_boubou_att - $deg_brut_destroy_att ; /* on enlève du sigma boubou
la valeur correspondante */

$x = $destroy_sigma_boubou_att ;
$y = $percent_ori ;
$percent = verif_div_zero_per_cent ($x, $y) ; // calcul du % de boubou restant (via la fonction donnée précédement)
$percent = number_format($percent,2) ; // on arrondit le pourcentage pour faire joli

echo "<p>Les [A]Destroyers subissent ".$deg_destroy_att." de dégats bruts. Les boucliers
absorbent ".$deg_destroy_att_abs." de ces dégats. Les boucliers sigma
absorbent ".$deg_brut_destroy_att." points de dégats.
Leur valeur est réduite de ce nombre. Les boucliers sigma tombent à <i>".$percent."%</i> de leurs capacités.</p>" ;

}
elseif ($deg_brut_destroy_att > $destroy_sigma_boubou_att)
{
$deg_brut_destroy_att = $deg_brut_destroy_att - $destroy_sigma_boubou_att ; // Tout d'abord on décompte du reste des boucliers
$destroy_sigma_boubou_att = 0 ; // le boubou sigma passe donc à 0
$destroy_pv_att = $destroy_pv_att - $deg_brut_destroy_att ; // les dégats s'attaquent direct au vaisseau
echo "<p>Les boucliers sigma des [A]Destroyers sont saturés ! La flotte attaquante leur inflige
".$deg_destroy_att." points de dégats. Ils subissent à l'arrivée ".$deg_brut_destroy_att."
points de dégats.</p>";
}
else
{
echo "<p> Erreur fatale n°1. Arrêt du script. Contactez l'administrateur :".$mel_admin.".</p>" ;
Die () ;
}

/* [D]DESTROYERS : script boubou */
$deg_brut_destroy_def = $deg_destroy_def * $destroy_abs_boubou_def ;
$deg_destroy_def_abs = $deg_destroy_def - ( $deg_destroy_def * $destroy_abs_boubou_def ) ;

if ($deg_brut_destroy_def <= $destroy_sigma_boubou_def)
{
$percent_ori = $destroy_sigma_boubou_def ; // pour le calcul du %, on a besoin d'une valeur d'origine
$destroy_sigma_boubou_def = $destroy_sigma_boubou_def - $deg_brut_destroy_def ; /* on enlève du sigma boubou
la valeur correspondante */

$x = $destroy_sigma_boubou_def ;
$y = $percent_ori ;
$percent = verif_div_zero_per_cent ($x, $y) ; // calcul du % de boubou restant (via la fonction donnée précédement)
$percent = number_format($percent,2) ; // on arrondit le pourcentage pour faire joli

echo "<p>Les [D]Destroyers subissent ".$deg_destroy_def." de dégats bruts. Les boucliers
absorbent ".$deg_destroy_def_abs." de ces dégats. Les boucliers sigma
absorbent ".$deg_brut_destroy_def." points de dégats.
Leur valeur est réduite de ce nombre. Les boucliers sigma tombent à <i>".$percent."%</i> de leurs capacités.</p>" ;

}
elseif ($deg_brut_destroy_def > $destroy_sigma_boubou_def)
{
$deg_brut_destroy_def = $deg_brut_destroy_def - $destroy_sigma_boubou_def ; // Tout d'abord on décompte du reste des boucliers
$destroy_sigma_boubou_def = 0 ; // le boubou sigma passe donc à 0
$destroy_pv_def = $destroy_pv_def - $deg_brut_destroy_def ; // les dégats s'attaquent direct au vaisseau
echo "<p>Les boucliers sigma des [D]Destroyers sont saturés ! La flotte attaquante leur inflige
".$deg_destroy_def." points de dégats. Ils subissent à l'arrivée ".$deg_brut_destroy_def."
points de dégats.</p>";
}
else
{
echo "<p> Erreur fatale n°1. Arrêt du script. Contactez l'administrateur :".$mel_admin.".</p>" ;
Die () ;
}

echo "<p>Les PV totaux des [A]Scouts passent à ".$scout_pv_att." après le round.</p>" ;
echo "<p>Les PV totaux des [D]Scouts passent à ".$scout_pv_def." après le round.</p>" ;
echo "<p>Les PV totaux des [A]Destroyers passent à ".$destroy_pv_att." après le round.</p>" ;
echo "<p>Les PV totaux des [D]Destroyers passent à ".$destroy_pv_def." après le round.</p>" ;

// on vire les groupes s'il n'y a plus de vaisseaux à cause des PV totaux qui chuttent à 0

if ($scout_pv_att <= 0)
{
echo "<p><b>Tous les [A]Scouts ont été détruits.</b></p>" ;
$group_scout_att = 0 ;
$scout_pv_att = 0 ; // on fout la valeur à 0 pour éviter les valeurs négatives
}
else
{
}

if ($scout_pv_def <= 0)
{
$group_scout_def = 0 ;
$scout_pv_def = 0 ;
echo "<p><b>Tous les [D]Scouts ont été détruits.</b></p>" ;
}
else
{
}

if ($destroy_pv_att <= 0)
{
$group_destroy_att = 0 ;
$destroy_pv_att = 0 ;
echo "<p><b>Tous les [A]Destroyers ont été détruits.</b></p>" ;
}
else
{
}

if ($destroy_pv_def <= 0)
{
$group_destroy_def = 0 ;
$destroy_pv_def = 0 ;
echo "<p><b>Tous les [D]Destroyers ont été détruits.</b></p>" ;
}
else
{
}

// ATTENTION : ne pas oublier la loi fondamentale n°1
/*
$n_vx_tot_att = ;
$n_vx_tot_def = ;

• /

// Variables destinées à la ré-unitialisation de la boucle
$n_round = $n_round + 1 ;
$sigma_group_att = $group_scout_att + $group_destroy_att ;
$sigma_group_def = $group_scout_def + $group_destroy_def ;

} // fin de la boucle principale
echo "<div align=center>FIN DU COMBAT</div>" ;
?>

Erreur 432 : Les forums de jv.com ne prennent pas en compte l'indentation de votre code source. Veuillez poster votre code sur pastebin. http://pastebin.com/

C'est très moche comme ça. J'ai vraiment pas eu le courage de tout lire !