Sans vouloir manquer de respect à l’auteur, je trouve ce module ridiculement complexe pour un débutant, notamment l’activité finale qui en plus d’être très absconse, n’apporte pratiquement aucun d’intérêt à l’apprentissage d’un débutant.
La POO demande un certain effort d’abstraction, et ce n’est pas évident si l’on n’a pas déjà une bonne expérience en programmation. Quand on apprend de la POO, on commence en général avec des classes plus concrètes comme cela était le cas en début de cours avec les personnages. Les design patterns et surtout le framework fait maison est totalement hors sujet pour moi. Ces notions appartiennent à un autre cours, et sûrement pas à un cours de POO pour débutant.
L’activité finale demande de bien comprendre le Framework créé par l’auteur. Je soupçonne l’auteur d’avoir eu envie de se faire un kiff au détriment des apprenants. A quoi bon comprendre son Framework et sa façon de faire (dont certaines approches sont discutables). L’exercice final ne nécessite pas la grande partie de ce qui a été vu dans ce cours ! On s’entraîne juste à apprendre un Framework qui ne servira jamais (autant s’attaquer tout de suite à Symfony ou Zend Framework).
Le risque de ce cours est d’affoler beaucoup de débutants qui n’arriveront pas à faire cet exercice, et à les décourager. Oui, il y a beaucoup à apprendre pour devenir bon développeur, mais il faut aussi beaucoup de pratique et d’expérience pour en arriver là. Le maître-mot est d’y aller progressivement, ce que ne fait pas ce cours.
Si vous avez été découragés par ce cours, ne pensez pas que vous êtes nuls. Les premières parties sont intéressantes, ensuite le cours n’est plus vraiment pédagogique pour un débutant. Si vous faites un Parcours, laissez ce module de côté quand vous bloquez, et allez vous entraîner avec d’autres sources. Revenez valider votre certificat plus tard quand vous aurez déjà réalisé quelques projets concrets en POO autre qu’un Framework très abstrait aux concepts multiples qui vont bien au-delà d’un cours pour débutant. Ce cours pourrait facilement être divisé en trois cours différents.
J'ai commencé le cours sur la POO et je suis arrivé à : [Théorie] Les bases de la POO; Chapitre 4.
Juste avant de commencer la partie sur l'hydratation, j'ai voulu créer un fichier PHP avec la récupération de la BDD et un avec la classe personnage mais lorsque je lance ma page rien ne se passe.
Si je lance un bon vieux tableau et que je boucle dessus je récupère bien les données, cela dois coincer au moment de l'instanciation.
Pouvez vous m'éclairer ?
Un fichier appelé Personnage.php (copier coller du cours)
Et mon fichier index.php dont voici le code
<?php
function chargerClasse($classe)
{
require $classe . '.php'; // On inclut la classe correspondante au paramètre passé.
}
spl_autoload_register('chargerClasse'); // On enregistre la fonction en autoload pour qu'elle soit appelée dès qu'on instanciera une classe non déclarée.
try
{
// On se connecte à MySQL
$bdd = new PDO('mysql:host=localhost;dbname=poo;charset=utf8', 'root', '');
}
catch(Exception $e)
{
// En cas d'erreur, on affiche un message et on arrête tout
die('Erreur : '.$e->getMessage());
}
// On admet que $bdd est un objet PDO.
$request = $bdd->query('SELECT id, nom, forcePerso, degats, niveau, experience FROM personnages');
while ($donnees = $request->fetch(PDO::FETCH_ASSOC)) // Chaque entrée sera récupérée et placée dans un array.
{
// On passe les données (stockées dans un tableau) concernant le personnage au constructeur de la classe.
// On admet que le constructeur de la classe appelle chaque setter pour assigner les valeurs qu'on lui a données aux attributs correspondants.
$perso = new Personnage($donnees);
echo $perso->nom(), ' a ', $perso->forcePerso(), ' de force, ', $perso->degats(), ' de dégâts, ', $perso->experience(), ' d\'expérience et est au niveau ', $perso->niveau();
}
?>
Cela dit avec ce cours et après le début du cours, je trouvais le cours long et ennuyeux, pas assez d'exo explicites.
J'ai un ami prof qui m'a dit que le TP est bc trop dur pour les débutants et le cours pas top...
Cela dit je voudrais avancer dans mon parcours, donc je vais sécher ce TP, j'espère que les correcteurs ne vont pas me lyncher ^^.
J'ai acheter un bon livre sur Php, je vais voir la Poo Php avec ce livre, où il y a bc d'exo.
Effectivement ce cours je l'ai compris théoriquement mais bien que le sujet soit délicat, il faut penser aux débutants et en plus apprendre sur le net n'est pas facile.
Spartak a écrit:
Sans vouloir manquer de respect à l’auteur, je trouve ce module ridiculement complexe pour un débutant, notamment l’activité finale qui en plus d’être très absconse, n’apporte pratiquement aucun d’intérêt à l’apprentissage d’un débutant.
La POO demande un certain effort d’abstraction, et ce n’est pas évident si l’on n’a pas déjà une bonne expérience en programmation. Quand on apprend de la POO, on commence en général avec des classes plus concrètes comme cela était le cas en début de cours avec les personnages. Les design patterns et surtout le framework fait maison est totalement hors sujet pour moi. Ces notions appartiennent à un autre cours, et sûrement pas à un cours de POO pour débutant.
L’activité finale demande de bien comprendre le Framework créé par l’auteur. Je soupçonne l’auteur d’avoir eu envie de se faire un kiff au détriment des apprenants. A quoi bon comprendre son Framework et sa façon de faire (dont certaines approches sont discutables). L’exercice final ne nécessite pas la grande partie de ce qui a été vu dans ce cours ! On s’entraîne juste à apprendre un Framework qui ne servira jamais (autant s’attaquer tout de suite à Symfony ou Zend Framework).
Le risque de ce cours est d’affoler beaucoup de débutants qui n’arriveront pas à faire cet exercice, et à les décourager. Oui, il y a beaucoup à apprendre pour devenir bon développeur, mais il faut aussi beaucoup de pratique et d’expérience pour en arriver là. Le maître-mot est d’y aller progressivement, ce que ne fait pas ce cours.
Si vous avez été découragés par ce cours, ne pensez pas que vous êtes nuls. Les premières parties sont intéressantes, ensuite le cours n’est plus vraiment pédagogique pour un débutant. Si vous faites un Parcours, laissez ce module de côté quand vous bloquez, et allez vous entraîner avec d’autres sources. Revenez valider votre certificat plus tard quand vous aurez déjà réalisé quelques projets concrets en POO autre qu’un Framework très abstrait aux concepts multiples qui vont bien au-delà d’un cours pour débutant. Ce cours pourrait facilement être divisé en trois cours différents.
J'ai commencé le cours sur la POO et je suis arrivé à : [Théorie] Les bases de la POO; Chapitre 4.
Juste avant de commencer la partie sur l'hydratation, j'ai voulu créer un fichier PHP avec la récupération de la BDD et un avec la classe personnage mais lorsque je lance ma page rien ne se passe.
Si je lance un bon vieux tableau et que je boucle dessus je récupère bien les données, cela dois coincer au moment de l'instanciation.
Pouvez vous m'éclairer ?
Un fichier appelé Personnage.php (copier coller du cours)
Et mon fichier index.php dont voici le code
<?php
function chargerClasse($classe)
{
require $classe . '.php'; // On inclut la classe correspondante au paramètre passé.
}
spl_autoload_register('chargerClasse'); // On enregistre la fonction en autoload pour qu'elle soit appelée dès qu'on instanciera une classe non déclarée.
try
{
// On se connecte à MySQL
$bdd = new PDO('mysql:host=localhost;dbname=poo;charset=utf8', 'root', '');
}
catch(Exception $e)
{
// En cas d'erreur, on affiche un message et on arrête tout
die('Erreur : '.$e->getMessage());
}
// On admet que $bdd est un objet PDO.
$request = $bdd->query('SELECT id, nom, forcePerso, degats, niveau, experience FROM personnages');
while ($donnees = $request->fetch(PDO::FETCH_ASSOC)) // Chaque entrée sera récupérée et placée dans un array.
{
// On passe les données (stockées dans un tableau) concernant le personnage au constructeur de la classe.
// On admet que le constructeur de la classe appelle chaque setter pour assigner les valeurs qu'on lui a données aux attributs correspondants.
$perso = new Personnage($donnees);
echo $perso->nom(), ' a ', $perso->forcePerso(), ' de force, ', $perso->degats(), ' de dégâts, ', $perso->experience(), ' d\'expérience et est au niveau ', $perso->niveau();
}
?>
Tu peux donner ton c/c de personnages stp ? Y'en a plusieurs dans le cours donc j'aimerais voir lequel tu as. Et on est d'accord que tu as une page blanche ?
@MarlyseCharlotteBisso Enlève l'accent dans le nom de ton fichier connection_base_donnees.php ça peut provenir de ça.
Désolé du temps de réponse, je n'étais pas chez moi. Pour le code du personnage j'ai repris celui du chapitre (en copier /coller)
<?php
class Personnage
{
private $_id;
private $_nom;
private $_forcePerso;
private $_degats;
private $_niveau;
private $_experience;
// Liste des getters
public function id()
{
return $this->_id;
}
public function nom()
{
return $this->_nom;
}
public function forcePerso()
{
return $this->_forcePerso;
}
public function degats()
{
return $this->_degats;
}
public function niveau()
{
return $this->_niveau;
}
public function experience()
{
return $this->_experience;
}
// Liste des setters
public function setId($id)
{
// On convertit l'argument en nombre entier.
// Si c'en était déjà un, rien ne changera.
// Sinon, la conversion donnera le nombre 0 (à quelques exceptions près, mais rien d'important ici).
$id = (int) $id;
// On vérifie ensuite si ce nombre est bien strictement positif.
if ($id > 0)
{
// Si c'est le cas, c'est tout bon, on assigne la valeur à l'attribut correspondant.
$this->_id = $id;
}
}
public function setNom($nom)
{
// On vérifie qu'il s'agit bien d'une chaîne de caractères.
if (is_string($nom))
{
$this->_nom = $nom;
}
}
public function setForcePerso($forcePerso)
{
$forcePerso = (int) $forcePerso;
if ($forcePerso >= 1 && $forcePerso <= 100)
{
$this->_forcePerso = $forcePerso;
}
}
public function setDegats($degats)
{
$degats = (int) $degats;
if ($degats >= 0 && $degats <= 100)
{
$this->_degats = $degats;
}
}
public function setNiveau($niveau)
{
$niveau = (int) $niveau;
if ($niveau >= 1 && $niveau <= 100)
{
$this->_niveau = $niveau;
}
}
public function setExperience($experience)
{
$experience = (int) $experience;
if ($experience >= 1 && $experience <= 100)
{
$this->_experience = $experience;
}
}
}
?>
Lorsque je charge la page j'ai "a de force, de dégâts, d'expérience et est au niveau a de force, de dégâts, d'expérience et est au niveau a de force, de dégâts, d'expérience et est au niveau"
Comme si il n'arrivai pas à lire la BDD (celle ci est identique à celle au début du chapitre)
C'est normal, ton code personnage ne contient pas la fonction hydrate ni de constructeur. C'est à toi de coder avec le cour ces deux fonctions qui permettront de set un objet en fonction de valeurs données sous formes de tableau. En gros tu donnes à ton personnage un ensemble de données, mais il n'en fait rien du tout, il n'appelle pas les setter, et donc, les attributs restent vident. Donc en toute logique, rien ne s'affiche.
Tu verra en continuant le cours comment créer l'hydratation, méthode qui consiste à remplir les attributs d'un objet à l'aide d'un array.
Problème dans le TP personnages spécialisés : Warning: PDOStatement::execute(): SQLSTATE[23000]: Integrity constraint violation: 1048 Le champ 'typePerso' ne peut �tre vide (null) in C:\wamp\www\test\PersonnagesManager.php on line 20.
Bonjour à tous et à toutes,
A chaque TP un problème conséquent, ici je rencontre un problème dans la création des personnages. En effet j'ai l'impression que dans la fonction ADD, l'hydratation de la propriété type de l'objet ne se fait pas puisque PHP me renvoie le message que typePerso ne peut être vide (null).
J'ai d'abord cru que cela venait du fait que l'appellation initiale de cette propriété était type ce qui peut créer des conflits avec MySQL d'où l'appellation typePerso que j'ai adoptée.
J'ai après envisagé que cela pouvait venir de l'absence de setter pour cet attribut dans la classe Personnage, en effet la fonction hydrate fait appel au setter, mais ça n'a pas l'air d'être cela.
J'ai également envisagé que c'était dans la BDD l'absence de valeur par défaut pour typePerso qui posait problème.
Autant j'arrive très aisément, même si je dois me creuser la tête par moment afin de résoudre quelques problèmes quand ils surviennent, autant je rencontre de manière récurrente des problèmes depuis que j'ai commencé la POO PHP, toujours un peu de même type, d'inscription dans la BDD.
Ici le problème à l'air de venir de la ligne 20 (mais il faut se méfier et regarder partout) de la classe PersonnagesManager, là je bloque vraiment, merci par avance pour votre aide:
<?php
class PersonnagesManager
{
private $_db; //instance de PDO
public function __construct($_db)
{
$this->setDb($_db); // On indique qu'on doit se servir des valeurs contenues dans la variable $db.
}
public function add(Personnage $perso)//fonction d'ajouter un personnage à la BDD. Ici on utilis $perso parce qu'il n'y a pas de distinction entre les personnages
{
//Préparation de la requête d'insertion. L'id étant crée automatiquement, il nous suffit de rentrer le nom du personnage et son type, tout le reste est établie par défaut et varie automatiquement à chaque coup donné ou reçu.
$q = $this->_db->prepare('INSERT INTO personnages_v2(nom, typePerso) VALUES(:nom, :typePerso)');
//asignation des valeurs pour le nom du personnage.
$q->bindValue(':nom', $perso->nom());
$q->bindValue(':typePerso', $perso->typePerso());
//Exécution de la requête.
$q->execute();
//hydratation du personnage passé en paramètre avec assignation de son identifiant et des dégâts initiaux (=0).
$perso->hydrate([
'id' => $this->_db->lastInsertId(), // Ici on indique que la valeur de l'id est la dernière entrée grace à la fonction lasInsertId()
'degats' => 0, // On indique que la valeur initiale des dégats est 0
'atout' => 0 // On indique que la valeur initiale des atouts est de 0.
]);
}
public function count()//fonction de compter les personnage de la BDD.
{
//execute une requête COUNT() et retourne le nombre de résultats retourné.
return $this->_db->query('SELECT COUNT(*) FROM personnages_v2')->fetchColumn();
}
public function delete(Personnage $perso)//fonction de supprimer un personnage à la BDD.
{
//execute une requête de type DELETE.
$this->_db->exec('DELETE FROM personnages_v2 WHERE id = '.$perso->id());
}
public function exists($info)//fonction de savoir si un personnage existe
{
if (is_int($info))// On recherche soit par l'id : il aura pour 'id' $info.
{
return (bool) $this->_db->query('SELECT COUNT(*) FROM personnages_v2 WHERE id = ' .$info)->fetchColumn();//on exécute alors une requête COUNT() avec une clause WHERE, et on retourne un Booleen (vrai il existe ou faux il n'existe pas).
}
$q = $this->_db->prepare('SELECT COUNT(*) FROM personnages_v2 WHERE nom = :nom');//Soit par le nom.
$q->execute([':nom' => $info]);//Exécution d'une requête COUNT() avec clause WHERE, et retourne un booleen (vrai il existe ou faux il n'existe pas).
return (bool) $q->fetchColumn();
}
public function get($info) //fonction de selectionner un personnage
{
if (is_int($info))//Si le paramètre est un entier, on veut récupérer le personnage avec son indentifiant.
{
$q = $this->_db->query('SELECT id, nom, degats, timeEndormi, typePerso, atout FROM personnages_v2 WHERE id = '.$info);//Execute une requête de type SELECT avec une clause WHERE, et retourne un objet Personnage.
$perso = $q->fetch(PDO::FETCH_ASSOC); // On utilise $perso car le type de personnage est multiple et donc peut varier.
}
else
{
$q = $this->_db->prepare('SELECT id, nom, degats, timeEndormi, typePerso, atout FROM personnages_v2 WHERE nom = :nom');//Sinon, on veut récupérer le personnage avec son nom.
$q->execute([':nom' => $info]);//Execute une requête de type SELECT avec une clause WHERE, et retourne un objet personnage.
$perso = $q->fetch(PDO::FETCH_ASSOC);
}
switch ($perso['typePerso']) // Ici on utilise une condition switch pour déterminer le type du personnage soit c'est guerrier qui est choisi et la variable $perso aura pour valeur guerrier, soit ce sera magicien et alors $perso aura pour valeur magicien. Le défaut renvoye null, le choix est obligatoire.
{
case 'guerrier':
return new Guerrier($perso);
case 'magicien':
return new Magicien($perso);
default:
return null;
}
}
public function getlist($nom)//Fonction qui retourne la liste des personnages dont le nom n'est pas $nom c'est à dire les autres personnages.
{
$persos = [];
$q = $this->_db->prepare('SELECT id, nom, degats, timeEndormi, typePerso, atout FROM personnages_v2 WHERE nom <> :nom ORDER BY nom');
$q->execute([':nom' => $nom]);
while ($donnees = $q->fetch(PDO::FETCH_ASSOC))
{ // Ici aussi le choix du type de personnage intervient donc on utilise une condition switch.
switch ($donnees['typePerso'])
{
case 'guerrier':
$persos[] = new Guerrier($donnees);
break;
case 'magicien':
$persos[] = new Magicien($donnees);
break;
}
}
return $persos;
//le résultat sera un tableau d'instances de Personnage.
}
public function update(Personnage $perso) //fonction qui modifie le personnage. Le type une fois déterminé à la création ne peut pas être modifié donc il n'apparaît dans cette partie.
{
$q = $this->_db->prepare('UPDATE personnages_v2 SET degats = :degats, timeEndormi = :timeEndormi, atout = :atout WHERE id = :id');//Prépare une requête de type UPDATE.
$q->bindValue(':degats', $perso->degats(), PDO::PARAM_INT);
$q->bindValue(':timeEndormi', $perso->timeEndormi(), PDO::PARAM_INT);
$q->bindValue(':atout', $perso->atout(), PDO::PARAM_INT);
$q->bindValue(':id', $perso->id(), PDO::PARAM_INT);//Assignation des valeurs à la requête.
$q->execute();//Exécution de la requête.
}
public function setDb(PDO $db)//la fonction setter pour modifier l'attribut $_db
{
$this->_db = $db;
}
}
?>
<?php
abstract class Personnage // En rendant la classe Personnage abstraite on oblige à créer de personnages spécialisés grâce aux classes héritantes Guerrier et Magicien.
{
// Les classes héritantes doivent avoir accès aux attributs de déclaré dans la classe mère, on passe donc la visibilité de private à protected.
protected $_atout,
$_degats,
$_id,
$_nom,
$_timeEndormi,
$_typePerso;
/*Les constantes sont des "attributs" dont la valeur invariable. Elles s'appliques à n'importe quel objet instancié et quel que soit le moment de l'exécution du script*/
const CEST_MOI = 1; // Cette constante est utilisée pour dire que c'est nous et que nous ne pouvons pas subir l'action demandée.
const PERSONNAGE_TUE = 2; // Cette constante est renvoyée lorsque dans la méthode implémentée la valeur de l'attribut utilisé atteint ou dépasse une certaine valeur.
const PERSONNAGE_FRAPPE = 3; // Cette constante est renvoyée comme message pour que dans la méthode implémentée on indique qu'on n'a pas atteint le nombre de point demandé pour tuer le personnage frappé.
/* 1,2 et 3: on indique juste l'ordre des constantes dans le script, la constante 1 CEST_MOI arrive à la ligne 22 du script, la constante 2 PERSONNAGE_TUE à la ligne 49 et la constante 3 PERSONNAGE_FRAPPE à la ligne 52.*/
const PERSONNAGE_ENSORCELE = 4; // Constante renvoyée par la méthode 'LancerUnSort (voir classe magicien' si on a bien ensorcelé un personnage (Je ne l'avais pas mise).
const PAS_DE_MAGIE = 5; // Constante renvoyée par la méthode 'LancerUnSort (voir classe magicien' lorsque l'atout du magicien est = 0 et que l'on veut jeter un sort
const PERSONNAGE_ENDORMI = 6; // Cette constante est utilisée pour signifier que le personnage que l'on utilise est endormi et ne peut donc pas produire l'action demandée.
/*Je ne comprends pas la différence entre la constante PERSONNAGE_ENSORCELE & PERSONNAGE_ENDORMI, ainsi que la présence de certaines de ces constantes (PERSONNAGE_ENSORCELE & PAS_DE_MAGIE) dans cette classe puisqu'elle porte sur la classe magicien.*/
public function __construct(array $donnees)
{
$this->hydrate($donnees); // On place grâce à $this (l'objet utilisé actuel) les valeurs contenues dans la variable $donnees (du fichier index.php) dans la fonction hydrate.
$this->typePerso = strtolower(static::class); // grace à cela nous pourrons déterminer de quel type de personnage il s'agit, le mot clef static renvoie le nom de la classe fille utilisée (magicien ou guerrier). Si nous avions utilisé le mot clef self cela aurait renvoyé le nom de la classe mère donc aucun interet. C'est de la résolution statique à la volée. La fonction strtolower permet d'obtenir un type en minuscule pour éviter les bugs.
}
public function estEndormi()
{
return $this->_timeEndormi > time(); // Cette méthode est utilisé comme une méthode de rappel et indique le temps pendant lequel le personnage qui souhaite frapper ne peut le faire car il est endormi à l'aide de la fonction time().
}
public function frapper(Personnage $perso)
{
if ($perso->id() == $this->_id)// Avant tout : vérifier qu'on ne se frappe pas soi-même.
{
return self::CEST_MOI;
}/* Si c'est le cas, on stoppe tout en renvoyant une valeur signifiant que le personnage ciblé est le personnage qui attaque. On utilise :: et self car c'est une constante*/
// Il faut verifier (donc utilisation d'une condition if) que le personnage qui doit frapper n'est pas endormi sinon il ne peut pas le faire. Il faudra alors utiliser une constante pour le signifier.
if ($this->estEndormi()) // La condition if prend cette forme puisque on se sert d'une autre méthode en argument.
{
return self::PERSONNAGE_ENDORMI;
}
return $perso->recevoirDegats();/* Le résutlat de la fonction frapper est que ler personnage frappé doit recevoir des dégats On indique au personnage frappé qu'il doit recevoir des dégâts.*/
}
public function hydrate(array $donnees) // Un tableau de données doit être passé à la fonction (d'où le préfixe « array ») $donnees est déclarée dans le fichier index.php.
{
foreach ($donnees as $key => $value) // On utilise une boucle spécifique pour les tableau $foreach.
{
// On récupère le nom du setter correspondant à l'attribut.
$method ='set'.ucfirst($key);
if (method_exists($this, $method)) // Si le setter correspondant existe.
{
// On appelle le setter.
$this->$method($value);
}
}
}
public function nomValide()
{
return !empty($this->_nom); // On verifie que le champ nom n'est pas vide !empty (!=non empty= vide).
}
public function recevoirDegats()
{
$this->_degats += 5;// On augmente de 5 les dégâts.
if ($this->degats >= 0 && $this->degats)
{
$this->atout = 4;
}
elseif ($this->degats > 25 && $this->degats)
{
$this->atout = 3;
}
elseif ($this->degats > 50 && $this->degats)
{
$this->atout = 2;
}
elseif ($this->degat > 75 && $this->degats)
{
$this->atout = 1;
}
else
{
$this->atout = 0;
}
if ($this->_degats >= 100)
{
return self::PERSONNAGE_TUE;
} /* Si on a 100 de dégâts ou plus, la méthode renverra une valeur signifiant que le personnage a été tué */
return self::PERSONNAGE_FRAPPE;// Sinon, elle renverra une valeur signifiant que le personnage a bien été frappé.
}
public function reveil()
{
// Il devra utiliser un timestamp pour savoir quand le sort prend fin, sachant que la durée varie en fonction de l'atout de celui qui a lancé un sort ($perso->atout * 6) * 3600 secondes.
$secondes = $this->_timeEndormi; // Ici on déclare la variable $secondes en disant que la valeur qui lui est assigné est la valeur de l'attribut timeEndormi pour le personnage utilisée.
$secondes -= time(); // Ici on indique que la valeur assignée à la variable $seconde diminue (-=) en fonction du timestamp donné par la fonction time().
$heures = floor($secondes / 3600); // Ici on détermine la valeur assignée à la variable $heure. Il faut lire l'instruction de droite à gauche: il y a 3600 secondes dans 1 heure donc ici si la variable $secondes à pour valeur $secondes = 3600 / 3600 la valeur assignée à $heures sera 1. La fonction floor() est utilisée pour arrondire au nombre entier inférieur le résultat de l'opération passée en paramètres.
$secondes -= $heures * 3600; // idem que la ligne précédent mais dans le sens inverse
$minutes = floor($secondes / 60); // idem que la première ligne mais pour la variable $minutes
$secondes -= $minutes * 60;
$heures .= $heures <= 1 ? ' heure ' : 'heures';
$minutes .= $minutes <= 1 ? ' minute ' : ' minutes';
$secondes .= $secondes <= 1 ? ' seconde ' : ' secondes';
return $heures . ', ' .$minutes . ' et ' .$secondes;
}
//définition des getter, ce qui permet au script de connaître l'état de l'objet.
public function atout()
{
return $this->_atout;
}
public function degats()
{
return $this->_degats;
}
public function id()
{
return $this->_id;
}
public function nom()
{
return $this->_nom;
}
public function timeEndormi()
{
return $this->_timeEndormi;
}
public function typePerso()
{
return $this->_typePerso;
}
//définition des setter, ce qui permet de modifier l'état des objets
public function setAtout($atout) // On place toujours l'attribut que le setter doit modifier en paramètre.
{
$atout = (int) $atout;
if ($atout >= 0 && $atout <=100)
{
$this->_atout = $atout;
}
}
public function setDegats($degats)
{
$degats = (int) $degats; //On vérifie que l'attributs dégats et bien un nombre entier
if ($degats >=0 && $degats <=100) // On vérifie que la valeur est bien comprise entre 0 et 100
{
$this->_degats = $degats; //on demande de ne retourner la valeur
}
}
public function setId($id)
{
$id = (int) $id;
if ($id > 0)
{
$this->_id = $id;
}
}
public function setNom($nom)
{
if (is_string($nom)) //on vérifie que c'est bien une chaine de caractères
{
$this->_nom = $nom;
}
}
public function setTimeEndormi($time) // Ici on modifie une variable d'une fonction de rappel et non l'attribut.
{
$this->_timeEndormi = (int) $time; // On contract la syntaxe car il n'y a pas de condition.
}
public function setTypePerso($typePerso) // Normalement on ne devrait pas en avoir besoin car on ne doit pas avoir à changer de type de personnage.
{
$this->_typePerso = $typePerso;
}
}
?>
<?php
//on remet l'autoload de la page d'index pour ne pas interrompre la boucle
function chargerClasse($classname)
{
require $classname.'.php';
}
spl_autoload_register('chargerClasse');
session_start(); // On appelle session_start() Après avoir enregistré l'autoload.
if (isset($_GET['deconnexion']))
{
session_destroy();
header('Location: .');
exit();
}
$_db = new PDO('mysql:host=localhost;dbname=jeux_combat', 'root', '');
$_db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING); // On émet toujours une alerte à chaque fois qu'une requête a échoué.
$manager = new PersonnagesManager($_db);
if (isset($_SESSION['perso']))
{
$perso = $_SESSION['perso'];
}
if (isset($_POST['creer']) && isset($_POST['nom'])) // On verifie la validité des données lorsqu'on crée un personnage.
{
switch ($_POST['typePerso']) // On choisit le type de personnage.
{
case 'magicien' :
$perso = new Magicien(['nom' => $_POST['nom']]);
break;
case 'guerrier' :
$perso = new Guerrier(['nom' => $_POST['nom']]);
break;
default:
$message = 'Le type du personnage est invalide.';
break;
}
if (isset($perso)) // Si le type du personnage est valide, on crée un personnage.
{
if (!$perso->nomvalide()) // Le choix du nom n'est pas valide, on renvoie ce message.
{
$message = 'le nom choisi est invalide.';
unset($perso);
}
elseif ($manager->exists($perso->nom())) // sinon si Le nom choisi est déjà pris, on renvoie ce message.
{
$message = 'le nom du personnage est déjà pris.';
unset($perso);
}
else // Sinon on crée le personnage en appellant la fonction add() de personnageManager.
{
$manager->add($perso);
}
}
}
elseif (isset($_POST['utiliser']) && isset($_POST['nom'])) // On verifie la validité des données si l'on veut utiliser un personnage.
{
if ($manager->exists($_POST['nom'])) // si celui-ci existe.
{
$perso = $manager->get($_POST['nom']);
}
else
{
$message = 'Ce personnage n\'existe pas !'; // s'il n'existe pas, on affichera ce message
}
}
elseif (isset($_GET['frapper'])) //Si on a cliqué sur un personnage pour le frapper.
{
if (!isset($perso)) // Si l'on veut frapper une personnage sans avoir crée un personnage ou s'être identifié, on renvoie ce message.
{
$message = 'Merci de créer un personnage ou de vous identifier.';
}
else
{
if (!$manager->exists((int) $_GET['frapper'])) // Si on tente de frapper un personnage qui n'existe pas.
{
$message = 'le personnage que vous voulez frapper n\'existe pas!';
}
else
{
$persoAfrapper = $manager->get((int) $_GET['frapper']);
$retour = $perso->frapper($persoAfrapper); // On frappe le personnage en appelant la méthode frapper().
switch ($retour) // On stocke dans $retour les éventuelles erreurs ou messages que renvoie la méthode frapper.
{
case Personnage::CEST_MOI : // Lorsqu'on essaye de se frapper soi-même et que la constant CEST-MOI est renvoyé on affiche ce message
$message = 'Mais... pourquoi voulez-vous vous frapper ???';
break;
case Personnage::PERSONNAGE_FRAPPE : // Lorsqu'on frappe le personnage voulu et que la constante PERSONNAGE_FRAPPE est renvoyé on affiche ce message.
$message = 'Le personnage a bien été frappé !';
$manager->update($perso);
$manager->update($persoAfrapper);
break;
case Personnage::PERSONNAGE_TUE : // Lorsqu'on a atteint le niveau de dégat maximum et que la constante PERSONNAGE_TUE est renvoyé, on affiche ce message
$message = 'vous avez tué ce personnage !';
$manager->update($perso);
$manager->delete($persoAfrapper);
break;
case Personnage::PERSONNAGE_ENDORMI :
$message = 'Vous êtes endormi, vous ne pouvez pas de frapper de personnage ! ';
break;
}
}
}
}
elseif (isset($_GET['ensorceler'])) // L'action effectuée par un magicien d'ensorceler quelqu'un
{
if (!isset($perso)) // Si le personnage n'existe ou qu'on n'est pas identifier.
{
$message = 'Merci de créer une personnage ou de vous identifier.';
}
else // On vérifie que le personnage est bien un magicien.
{
if ($perso->typePerso() != 'magicien') // Si ce n'est pas le cas on affiche ce message
{
$message = 'Seuls les magiciens peuvent ensorceler des personnages !';
}
else
{
if (!$manager->exists((int) $_GET['ensorceler'])) // Lorsque l'on veut ensorceler un personnage qui n'existe pas, on affiche ce message.
{
$message = 'Le personnage que vous voulez ensorceler n\'existe pas !';
}
else
{
$persoAEnsorceler = $manager->get((int) $_GET['ensorceler']); // ici on jete un sort.
$retour = $perso->lancerUnSort($persoAEnsorceler); // et On gere les retours et erreurs.
switch ($retour)
{
case Personnage::CEST_MOI :// Si on essaye d'envoyer un sort à soi-même
$message = 'Mais... pourquoi voulez-vous vous ensorceler ???';
break;
case Personnage::PERSONNAGE_ENSORCELE : // On jete un sort, ce qui modifiera le personnage qui jete un sort et celui qui est ensorcelé et on affcihe ce message
$message = 'Le personnage a bien été ensorcelé !';
$manager->update($perso);
$manager->update($persoAEnsorceler);
break;
case Personnage::PAS_DE_MAGIE : // Lorsqu'on a plus d'atout et donc pas de magie on affiche ce message
$message = 'Vous n\'avez pas de magie !';
break;
case Personnage::PERSONNAGE_ENDORMI : // Lorsque on vous a jeté un sort et que vous êtes endormi.
$message = 'Vous êtes endormi, vous ne pouvez pas lancer de sort !';
break;
}
}
}
}
}
?>
<!DOCTYPE html>
<html>
<head>
<title>TP : Mini jeu de combat</title>
<meta charset="utf-8"/>
</head>
<body>
<p>Nombre de personnages créés : <?= $manager->count() ?></p> <!-- Dans ce type d'instruction en PHP, il faut ne pas indiquer PHP après le ? sinon cela soulève une erreur, le signe = doit être collé au ?-->
<?php
if (isset($message)) // On a un message à afficher ?
{
echo '<p>', $message, '</p>'; // Si oui, on l'affiche.
}
if (isset($perso)) // Si on utilise un personnage (nouveau ou pas).
{
?>
<p><a href="?deconnexion=1">Déconnexion</a></p>
<fieldset>
<legend>Mes informations</legend>
<p>
Type : <?= ucfirst($perso->typePerso()) ?><br>
Nom : <?= htmlspecialchars($perso->nom()) ?><br>
Dégâts : <?= $perso->degats() ?><br>
<?php
switch ($perso->typePerso())
{
case 'magicien':
echo 'Magie : ';
break;
case 'guerrier':
echo 'Protection : ';
break;
}
echo $perso->atout();
?>
</p>
</fieldset>
<fieldset>
<legend>Qui frapper?</legend>
<p>
<?php
$retourPersos = $manager->getList($perso->nom());
if (empty($retourPersos))
{
echo 'Personne à frapper !';
}
else
{
if ($perso->estEndormi())
{
echo 'Un magicien vous a endormi ! Vous allez vous réveiller dans ', $perso->reveil(), '.';
}
else
{
foreach ($retourPersos as $unPerso)
{
echo '<a href="?frapper=', $unPerso->id(), '">', htmlspecialchars($unPerso->nom()), '</a> (dégâts :', $unPerso->degats(), ' | type : ', $unPerso->typePerso(), ')';
// On ajoute un lein pour lancer un sort si le personnage est un magicien.
if ($perso->typePerso() == 'magicien')
{
echo ' | <a href="?ensorceler=', $unPerso->id(), '">Lancer un sort</a>';
}
echo '<br>';
}
}
}
?>
</p>
</fieldset>
<?php
}
else
{
?>
<form action="" method="post">
<p>
Nom : <input type="text" name="nom" maxlength="50" /><input type="submit" value="Utiliser ce personnage" name="utiliser" /><br>
Type :
<select name="typePerso">
<option value="magicien">Magicien</option>
<option value="guerrier">Guerrier</option>
</select>
<input type="submit" value="Créer ce personnage" name="creer" />
</p>
</form>
<?php
}
?>
</body>
</html>
<?php
if (isset($perso))// Si on a créé un personnage, on le stocke dans un variable session afin d'aconomiser une requête SQL.
{
$_SESSION['perso'] = $perso;
}
?>
<?php
class Magicien extends Personnage
{
/* Nous avons déclaré les attributs et les constantes de classe dans la classe mère pour ne pas à avoir à les redéclarer dans chacune des classes filles.*/
public function lancerUnSort(Personnage $perso) // On lance un sort à un autre personnage donc $perso et non $this.
{
// la valeur de l'atout est dégressif comme pour le guerrier.
if ($this->_degats >= 0 && $this->_degats <=25)
{
$this->_atout = 4;
}
elseif ($this->_degats > 25 && $this->_degats <= 50)
{
$this->_atout = 3;
}
elseif ($this->_degats > 50 && $this->_degats <= 75)
{
$this->_atout = 2;
}
elseif ($this->_degats > 75 && $this->_degats <= 90)
{
$this->_atout = 0;
}
if ($perso->id() == $this->_id)// Avant tout : vérifier qu'on ne se jete pas un sort à soi-même.
{
return self::CEST_MOI;
}
if ($this->_atout == 0) // Ici si l'atout du magicien est égal à 0, il ne peut pas lancer de sort
{
return self::PAS_DE_MAGIE;
}
if ($this->estEndormi()) // Ici si la fonction estEndormi renvoye une valeur booléenne true alors il ne peut pas lancer de sort puisqu'il est endormi.
{
return self::PERSONNAGE_ENDORMI;
}
$perso->timeEndormi = time() + ($this->_atout * 6 ) * 3600;
/*Le magicien aura la capacité d'endormir un autre magicien ou un guerrier pendant 6 heures multiplié par la valeur assignée à son atout (qui doit donc être progressif en fonction de l'experience. il convient donc de créer un attribut $atout. la formule est ($this->atout * 6) * 3600 secondes. $this parcqu'on peut lancer un sort à un guerrier comme à un magicien. */
return self::PERSONNAGE_ENSORCELE; // On renvoie au personnage qu'il est ensorcele.
}
}
?>
<?php
class Guerrier extends Personnage
{
/* Nous avons déclaré l'attribut $_atout; dans classe Personnage sa visibilité y est défini comme protected, il sera donc hérité et accessible dans cette classe. Ceci nous évite d'avoir à le redéclarer dans chaque classe héritière. */
public function recevoirDegats()
{
/* La méthode doit calculer la valeur de l'atout. Cette valeur est dégressive en fonction des dégats subits : Si les dégâts sont compris entre 0 et 25, alors l'atout sera de 4.
Si les dégâts sont compris entre 25 et 50, alors l'atout sera de 3.
Si les dégâts sont compris entre 50 et 75, alors l'atout sera de 2.
Si les dégâts sont compris entre 75 et 90, alors l'atout sera de 1.
Sinon, il sera de 0.*/
if ($this->_degats >= 0 && $this->_degats <= 25)
{
$this->_atout = 4;
}
elseif ($this->_degats > 25 && $this->_degats <= 50)
{
$this->_atout = 3;
}
elseif ($this->_degats > 50 && $this->_degats <= 75)
{
$this->_atout = 2;
}
elseif ($this->_degats > 75 && $this->_degats <= 90)
{
$this->_atout = 1;
}
else
{
$this->_atout = 0;
}
$this->_degats += 5 - $this->atout;// elle augmentera les dégâts en fonction de la valeur de l'atout calculé ci-dessus. la formule sera la valeur classique des dégats reçut pour 1 coup = 5- $atout (la valeur de $attout déterminé ci-dessus)
if ($this->_degats >= 100) // Elle indiquera si le personnage a été frappé ou tué.
{
return self::PERSONNAGE_TUE;
}
return self::PERSONNAGE_FRAPPE;
/*Voir comment on peut remplacer cette structure par switch*/
}
}
?>
J'allais proposé d'ajouter la fonction d'hydratation dans le contructeur car je me suis fait avoir étant donné que ce n'est pas explicite dans le cours. Mais d'après ce que je peut voir, ça semble être déjà fait
D'après le message d'erreur, tu crées une instance de Database dans le fichier table.php. Ouvre ce fichier, et à la ligne 29 tu as sans doute quelque chose du genre $db = new Database(... En faisant new Database, tu appelles le constructeur de cette classe, mais apparemment tu n'as pas indiqué les paramètres de ce constructeur ($database, $host, $uti, $pass). Si tu bloques, colle le contenu de table.php pour avoir plus d'infos.
@Christophevallot : je préfère aussi faire une concaténation par souci de lisibilité, mais PHP interprète bien les variables PHP quand elles sont dans un commentaire avec des double quotes. Si tu utilises des single quotes, alors ces variables ne seront considérées que comme du texte. Dans l'exemple, si $this->host = "localhost", alors :
bonjour je suis nouvelle voila j'ai un énorme soucis je suis entrain de concevoir une appli pour gérer le personnel d'une entreprise en php j'ai les heures supp a calculer et je ne sais pas comment faire vous pouvez svp me donné un coup de main
J'ai un problème avec son exemple de page protégée par un mot de passe.
J'ai essayé d'utiliser sa méthode. Comme ça ne marchait pas, j'ai créé deux fichiers tels que lui les écrit (formulaire.php et secret.php), et j'ai exactement la même erreur que quand j'essaie de faire l'exercice tout seul.
Il affiche le mot de passe ET le message d'erreur avec des bouts de code à la fin.
Quelqu'un peut-il me confirmer que sa correction est fausse ? Ou alors à quel moment de ma copie je me trompe ?
Quelqu'un a-t-il un lien pour une explication pas à pas pour une page protégée par un mot de passe ?
Bonjour, je viens poster un message a propos du cours sur la gestion des erreurs au niveau du tuto
avec la classe exception.
Je viens créer la classe exception et la classe enfant mon exception,
mais php m'affcihe ce code
" Fatal error: Non-abstract method Exception::getMessage() must contain body in /Applications/MAMP/htdocs/tests/POO/exeption.php on line 9 "
et après de multiples recherches je n'arrive pas à trouver la solution au
problème est-ce que quelqu'un pourrait m'aiguiller.
merci à vous.
ci-joint, mon code
<?php
class Exception
{
protected $message = 'exception inconnu'; // Message de l'exception.
protected $code = 0; // Code de l'exception défini par l'utilisateur.
protected $file; // Nom du fichier source de l'exception.
protected $line; // Ligne de la source de l'exception.
final function getMessage(); // Message de l'exception.
final function getCode(); // Code de l'exception.
final function getFile(); // Nom du fichier source.
final function getLine(); // Ligne du fichier source.
final function getTrace(); // Un tableau de backtrace().
final function getTraceAsString(); // Chaîne formattée de trace.
/* Remplacable */
function __construct ($message = NULL, $code = 0);
function __toString(); // Chaîne formatée pour l'affichage.
}
class MonException extends Exception
{
public function __construct($message, $code = 0)
{
parent::__construct($message, $code);
}
public function __toString()
{
return $this->message;
}
}
function additionner($a, $b)
{
if (!is_numeric($a) || !is_numeric($b))
{
throw new MonException('Les deux paramètres doivent être des nombres'); // On lance une exception "MonException".
}
if (func_num_args() > 2)
{
throw new Exception('Pas plus de deux arguments ne doivent être passés à la fonction'); // Cette fois-ci, on lance une exception "Exception".
}
return $a + $b;
}
try // Nous allons essayer d'effectuer les instructions situées dans ce bloc.
{
echo additionner(12, 3), '<br />';
echo additionner(15, 54, 45), '<br />';
}
catch (MonException $e) // Nous allons attraper les exceptions "MonException" s'il y en a une qui est levée.
{
echo '[MonException] : ', $e; // On affiche le message d'erreur grâce à la méthode __toString que l'on a écrite.
}
catch (Exception $e) // Si l'exception n'est toujours pas attrapée, alors nous allons essayer d'attraper l'exception "Exception".
{
echo '[Exception] : ', $e->getMessage(); // La méthode __toString() nous affiche trop d'informations, nous voulons juste le message d'erreur.
}
echo '<br />Fin du script'; // Ce message s'affiche, cela prouve bien que le script est exécuté jusqu'au bout.
1 - récupérer la liste des personnages, 2 - parmi cette liste je fais la sélection du bon personnage, 3 - la modification de l'expérience (dans l'objet personnageSelectionne), 4 - modification dans la base de données
- Cela fonctionne, l'experience est au final bien modifiée, mais la logique est t'elle bien bonne ? - l'appel de la fonction setExperience() peut elle se faire en dehors de la fonction hydrater()?
J'ai été en difficulté sur ce cours, dès le développement de la bibliothèque sur le dernier tiers et surtout lors de l'activité finale. Mon niveau en php se résumait à plus ou moins les notions de base suite à une formation courte comme première approche puis le cours phpMyAdmin d'OpenClassrooms.
J'ai refusé d'échouer
Le manque d'approche pédagogique est évident dans la dernière partie du cours, mais peut être volontaire... En effet l'architecture est très complexe pour une personne peut expérimentée mais nous avions vu toutes les notions nécessaires et puis il y biensûr la documentation. Je me suis dit que c'était pas normal de balancer un code si élaboré comme ça sans en expliquer chaque point à l'élève, et puis finalement c'est quoi qui m'attend en entreprise ? ...là j'ai pensé que le fait de débarquer dans un projet inconnu comme celui-là serait fréquent probablement, que construire un site partant de la première ligne de code serait rare.. Donc je savais qu'il fallait vraiment être capable d'intervenir sur cette activité.
Il est facile de mal se juger
Soyez tendre avec vous même, on peut vraiment se sentir con à regarder son écran pendant des heures et des heures sans trouver de solution. Moi à un moment j'ai parcourru ce forum et j'ai lu plein de messages d'élèves en détresse ou de critiques du cours, et bien ça m'a remonté le moral de savoir que je n'étais pas isolé et que beaucoup on passé un temps très long ici. Travaillez, lisez la documentation php, faites des dessins pour comprendre, relisez le cours, codez même si c'est très imparfait car chaque petit résultat est une pièce du puzzle.
L'énnoncé de l'exercice...
Ça c'est l'enfer !!! ...non sérieux c'était pas clair ! Bon répondez à chaque point et faites un code qui marche... puis améliorez... pensez objet... perso ma classe est tombée dans le procédurale un peu mais j'ai réussi à correspondre à ce qui est demandé sans dénaturer le "mécanisme" du site, j'aurais pu faire plus court. A ce jour j'attends d'être corrigé alors prudence avec mes conseils.
Important
Finalement j'ai le sentiment d'avoir beaucoup plus appris pendant l'activité finale que sur presque tout le cours, tellement d'essais que cela a fait mon expérience, tellement de mauvais essais que j'ai fini par cerner l'application. En fait après coup tout est plus clair, la pratique....
svp chere ami je rencontre probleme à faire verification age du client sur mon site dont je veux qu"il sois superieure de 18 est ce qu"il y a de solution .
Bonjour svp j'ai un problème d'encodage avec ma base de données par exemple si une personne entre un sujet sur un formulaire avec des accents comme: "ça concerne quelle qualité" sur phpmyadmin je vois des symboles bizarre à la place de "ç" et "é"
Sans vouloir manquer de respect à l’auteur, je trouve ce module ridiculement complexe pour un débutant, notamment l’activité finale qui en plus d’être très absconse, n’apporte pratiquement aucun d’intérêt à l’apprentissage d’un débutant.
La POO demande un certain effort d’abstraction, et ce n’est pas évident si l’on n’a pas déjà une bonne expérience en programmation. Quand on apprend de la POO, on commence en général avec des classes plus concrètes comme cela était le cas en début de cours avec les personnages. Les design patterns et surtout le framework fait maison est totalement hors sujet pour moi. Ces notions appartiennent à un autre cours, et sûrement pas à un cours de POO pour débutant.
L’activité finale demande de bien comprendre le Framework créé par l’auteur. Je soupçonne l’auteur d’avoir eu envie de se faire un kiff au détriment des apprenants. A quoi bon comprendre son Framework et sa façon de faire (dont certaines approches sont discutables). L’exercice final ne nécessite pas la grande partie de ce qui a été vu dans ce cours ! On s’entraîne juste à apprendre un Framework qui ne servira jamais (autant s’attaquer tout de suite à Symfony ou Zend Framework).
Le risque de ce cours est d’affoler beaucoup de débutants qui n’arriveront pas à faire cet exercice, et à les décourager. Oui, il y a beaucoup à apprendre pour devenir bon développeur, mais il faut aussi beaucoup de pratique et d’expérience pour en arriver là. Le maître-mot est d’y aller progressivement, ce que ne fait pas ce cours.
Si vous avez été découragés par ce cours, ne pensez pas que vous êtes nuls. Les premières parties sont intéressantes, ensuite le cours n’est plus vraiment pédagogique pour un débutant. Si vous faites un Parcours, laissez ce module de côté quand vous bloquez, et allez vous entraîner avec d’autres sources. Revenez valider votre certificat plus tard quand vous aurez déjà réalisé quelques projets concrets en POO autre qu’un Framework très abstrait aux concepts multiples qui vont bien au-delà d’un cours pour débutant. Ce cours pourrait facilement être divisé en trois cours différents.
Merci pour tes précisions Spartak
- Edité par ScottSupertramp 17 janvier 2018 à 19:08:46
Je n'ai pas la science infuse, j'en ai bavé comme vous, il y a déjà 2 ans. J'ai même tout arrêté lors de la dernière activité car pour moi aussi c'était difficile. J'ai suivi d'autres cours tout en me documentant sur les systèmes de cache: 6 mois après, je m'y suis remis et j'ai terminé l'exercice avec un beau 8/10 au final et une grande fierté. C'est vrai, il ne faut pas lâcher et, surtout, ce n'est jamais du tout cuit ! On fait un métier dans lequel il faut toujours se documenter et ce cours nous l'a bien montré.
La chute n'est pas un échec, l'échec c'est de rester là où on est tombé!
Christophe Vallot
Christophe Vallot
Christophe Vallot