Variable objet non reconnu en POO

Bonjour à tous,

Voilà, je viens ici, car je ne comprends vraiment pas mon erreur. J'essaye de faire les améliorations proposées dans le TP 1 d'un cours sur PHP en POO. J'en suis à celle où il faut limiter le nombre de coups à 3 par jours.

Par conséquent, voici ce que j'ai codé:
la classe PerosnageManager.php:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
<?php
 
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 * This class manages communication with database
 *
 * @author Benoît Puech
 */
class PersonageManager {
    private $_db;
 
    public function __construct(PDO $db) {
        $this->setDb($db);
    }
 
    public function add(Personnage $perso)
    {
        $q = $this->_db->prepare('INSERT INTO personnages(name, connexion_date)'
                . 'VALUES(:name, NOW())');
        $q->bindValue(':name', $perso->name());
        $q->execute();
 
        $perso->hydrate([
            'id' => $this->_db->lastInsertId(),
            'damages' => 0,
            'experience' => 0,
            'level' => 0,
            'strengh' => 5,
            'strokes' => 0,
        ]);
    }
 
    public function count() {
        /* 
         * Compte le nombre total de personnages stockés dans la BDD et retourne
         * ce nombre
         */
 
        // RETURN le nombre de persos dans la bdd via requête SELECT COUNT
        return $this->_db->query('SELECT COUNT(*) FROM personnages')->fetchColumn();
    }
 
    public function delete(Personnage $perso) {
        /* 
         * Supprime un personnage de la BDD en fonction de son ID 
         */
 
        // Requête DELETE via selection WHERE id=
        $q = $this->_db->query('DELETE FROM personnages WHERE id = '.$perso->id());
    }
 
    public function exists($info) {
       if (is_int($info))
       {
           return (bool) $this->_db->query('SELECT COUNT(*) FROM personnages WHERE id = '.$info)->fetchColumn();
       }
       $q = $this->_db->prepare('SELECT COUNT(*) FROM personnages WHERE name = :name');
       $q->execute([':name' => $info]);
 
       return (bool) $q->fetchColumn();
    }
 
    public function get($infos) {
        if (is_int($infos)) {
            $q = $this->_db->query('SELECT id, name, damages, experience, level, strengh FROM personnages WHERE id = '.$infos);
            $donnees = $q->fetch(PDO::FETCH_ASSOC);
            return new Personnage($donnees);
        } else {
            $q = $this->_db->prepare('SELECT id, name, damages, experience, level, strengh FROM personnages WHERE name = :name');
            $q->execute([':name' => $infos]);
            return new Personnage($q->fetch(PDO::FETCH_ASSOC));
        }
    }
 
    public function getConnexionDate($name) {
        $q = $this->_db->prepare('SELECT connexion_date FROM personnages WHERE name = ' . $name);
        $date = $q->fetch(PDO::FETCH_ASSOC);
 
        return $date;
    }
 
     public function getList($name)
    {
        $persos = [];
 
        $q = $this->_db->prepare('SELECT id, name, damages, experience, level, '
                . 'strengh FROM personnages WHERE name <> :nom ORDER BY name');
        $q->execute([':nom' => $name]);
 
        while ($donnees = $q->fetch(PDO::FETCH_ASSOC))
        {
            $persos[] = new Personnage($donnees);
        }
 
        return $persos;
    }
 
    public function getStrokes($info) {
        if (is_int($info)) {
            $q = $this->_db->prepare('SELECT strokes FROM personnages'
                    . 'WHERE id = ' . $info);
            $strokes = $q->fetch(PDO::FETCH_ASSOC);
 
            return $strokes;
        } else {
            $q = $this->_db->prepare('SELECT strokes FROM personnages'
                    . 'WHERE name = ' . $info);
            $strokes = $q->fetch(PDO::FETCH_ASSOC);
 
            return $strokes;
        }
    }
 
    public function update(Personnage $perso) {
        /*
         * Mets les dégats du personnage à jour dans la BDD en fonction ID
         */
 
        // UPDATE SET degats = WHERE id =
        // Bindvalue degats et id
        // execute
        $q = $this->_db->prepare('UPDATE personnages SET damages = :damages, experience = :experience, level = :level, strengh = :strengh'
                . ' WHERE id = :id');
        $q->bindValue(':damages', $perso->damages());
        $q->bindValue(':experience', $perso->experience());
        $q->bindValue(':level', $perso->level());
        $q->bindValue(':strengh', $perso->strengh());
        $q->bindValue(':id', $perso->id());
 
        $q->execute();
    }
 
    public function updateConnexionDate($info) {
        if (is_int($info)) {
            $q = $this->_db->query('UPDATE personnages SET connexion_date = NOW()'
                    . 'WHERE id = ' . $infos);
        } else {
            $q = $this->_db->prepare('UDATE personnages SET connexion_date = NOW()'
                    . 'WHERE name = :name');
            $q->execute([':name' => $info]);
        }
    }
 
    public function updateStrokesNumber($info, $strokes){
        if (is_int($info)) {
            $q = $this->_db->prepare('UPDATE personnages SET strokes = :strokes'
                    . 'WHERE id = :id');
            $q->execute([':strokes' => $strokes,
                         ':id' => $info]);
        } else {
            $q = $this->_db->prepare('UPDATE personnages SET strokes = :strokes'
                    . 'WHERE name = :name');
            $q->execute([':strokes' => $strokes,
                         ':name' => $name]);
        }
    }
 
    // SETTER //
    public function setDb($db) {
        $this->_db = $db;
    }
}

La classe Personnage.php:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
<?php
 
/**
 * This class allow to create and hydrate a character with data contained in database
 * 
 *
 * @author Benoît Puech
 */
class Personnage {
    private $_id,
            $_name,
            $_damages,
            $_experience,
            $_level,
            $_strengh;
 
    const CEST_MOI = 1;
    const PERSONNAGE_TUE = 2;
    const PERSONNAGE_FRAPPE = 3;
 
    public function __construct(array $donnees) {
        $this->hydrate($donnees);
    }
 
    /**
     * This function first checks if the character created does not hit himself and then, if is
     * not the case, allows damages to the character
     * 
     * @param Personnage $perso
     * @return damages the character is going to take
     */
    public function frapper(Personnage $perso) {
        if ($perso->id() == $this->_id) {
            return self::CEST_MOI;
        }
        return $perso->recevoirDegats($perso);
    }
    /**
     * Allocate data to the variables by calling related setter if it exists
     * 
     * @param array $donnees
     */
    public function hydrate(array $donnees)
    {
        foreach($donnees as $key => $value) {
            $method = 'set'.ucfirst($key);
            if (method_exists($this, $method)) {
                $this->$method($value);
            }
        }
    }
 
    /**
     * Checks if the name sent by user is correct
     * @return type string
     */
 
    public function nomValide() {
        return !empty($this->_name);
    }
 
    /**
     * Allocate damages to the character which was hit if the maximum damages is not reached (100). 
     * Otherwise it means the character is dead.
     * 
     * @param Personnage $perso
     * @return type
     */
    public function recevoirDegats(Personnage $perso) {
        $this->_damages += $this->_strengh;
 
        if ($this->_damages >= 100)
        {
            return self::PERSONNAGE_TUE;
        }
 
        return self::PERSONNAGE_FRAPPE;
    }
 
    // GETTERS //
    public function damages() { 
        return $this->_damages;
    }
 
    public function experience() {
        return $this->_experience;
    }
 
    public function id() {
        return $this->_id;
    }
 
    public function level() {
        return $this->_level;
 
    }
 
    public function name() {
        return $this->_name;
    }
 
    public function strengh() {
        return $this->_strengh;
    }
 
 
    // SETTER //
    public function setDamages($damages){
        $damages = (int)$damages;
 
        if ($damages >= 0 && $damages < 100)
        {
            $this->_damages = $damages;
        }
    }
 
    public function setExperience()
    {
        if ($this->_experience < 100)
        {
            $this->_experience += 10;
        } elseif ($this->_experience >= 100) {
            $this->_experience = 0;
            $this->setLevel(1);    
    }
    }
 
    public function setId($id) {
        $id = (int)$id;
 
        if ($id > 0)
        {
            $this->_id = $id;
        }
    }
 
    public function setLevel($level) {
        $level = (int) $level;
 
        if ($level >= 0 && $level <= 100) {
            $this->_level += $level;
            $this->setStrengh($level);
        }
    }
 
    public function setName($name) {
        if (is_string($name)){
            $this->_name = $name;
        }
    }
 
    public function setStrengh($level) {
        $level = (int) $level;
 
        switch (true) {
            case ($level >= 0 && $level < 10):
                $this->_strengh = 5;
                break;
            case ($level >= 10 && $level < 20):
                $this->_strengh = 10;
                break;
            case ($level >= 20 && $level < 30):
                $this->_strengh = 15;
                break;
            case ($level >= 30 && $level < 40):
                $this->_strengh = 20;
                break;
            case ($level >= 40 && $level < 50):
                $this->_strengh = 25;
                break;
            case ($level >= 50 && $level < 60):
                $this->_strengh = 30;
                break;
            case ($level >= 60 && $level < 70):
                $this->_strengh = 35;
                break;
            case ($level >= 70 && $level < 80):
                $this->_strengh = 40;
                break;
            case ($level >= 80 && $level <= 100):
                $this->_strengh = 45;
                break;
            default :
                echo 'Niveau inconnu';
                break;
        }
    }
}

Et enfin la page index.php:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
<?php
 
function chargerClasse($classeName) {
    require $classeName . '.php';
}
 
spl_autoload_register('chargerClasse');
 
$today = date('y-m-d');
 
session_start();
 
if (isset($_GET['deconnexion'])) {
    session_destroy();
    header('Location: .');
    exit();
 
}
 
$db = new PDO("mysql:host=localhost;dbname=test", 'root', '');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
 
$manager = new PersonageManager($db);
 
if(isset($_SESSION['perso'])) // Si la session perso existe, on restaure l'objet
{
    $perso = $_SESSION['perso'];
}
 
if (isset($_POST['creer']) && isset($_POST['nom'])) {
    $perso = new Personnage(['name' => $_POST['nom']]);
    $manager->updateConnexionDate($perso->id());
    if(!$perso->nomValide())
    {
        $message = 'Nom de personnage invalide';
        unset($perso);
    }
    elseif ($manager->exists($perso->name())) {
        $message = 'Le nom de personnage est déjà utilisé';
        unset($perso);
}
else 
{
    $manager->add($perso);
}
}
 
elseif (isset($_POST['utiliser']) && isset($_POST['nom'])) {
   $manager->updateConnexionDate($perso->name());
   $date = $manager->getConnexionDate($perso->name());
   $strokes = $manager->getSrokes($perso->id());
    if ($manager->exists($_POST['nom'])) { // SI le perso existe
        $perso = $manager->get($_POST['nom']); // On le selectionne dans la BDD
    }
    else {
       $message = 'Ce personnage n\'existe pas';
    }
}
elseif (isset($_GET['frapper'])) { // Si on a cliqué sur perso pour le frapper
    $date = $manager->getConnexionDate($perso->name());
    $strokes = $manager->getStrokes($perso->id());
    if (!isset($perso)) {
        echo 'Merci de créer un personnage ou de vous identifier';
    }
    else
    {
        if (!$manager->exists((int) $_GET['frapper'])) {
            echo 'Le personnage à frapper n\'existe pas';
        }
        else {
            if ($date == $today && $strokes < 3) {
                $persoAFrapper = $manager->get((int) $_GET['frapper']);
 
                $retour = $perso->frapper($persoAFrapper); // On stocke dans retour les éventuelles erreurs
 
                for ($i = 0;$i < 3;$i++) {
                            $manager->updateStrokesNumber($perso->id(), $i);
                    }
                switch($retour) {
                    case Personnage::CEST_MOI:
                        $message =  'Pourquoi voulez-vous vous frapper vous-même?';
                        break;
                    case Personnage::PERSONNAGE_FRAPPE:
                        $message = 'Le Personnage a bien été frappé';
 
                        $perso->setExperience();
 
                        $manager->update($perso);
                        $manager->update($persoAFrapper);
 
                        break;
 
                    case Personnage::PERSONNAGE_TUE:
                        $message = 'Vous avez tué ce personnage';
 
                        $perso->setExperience();
 
                        $manager->update($perso);
                        $manager->delete($persoAFrapper);
 
                        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>
    <?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>
        Nom : <?= htmlspecialchars($perso->name()); ?><br />
        Force : <?= $perso->strengh(); ?><br />
        Dégâts : <?= $perso->damages() ?><br />
        Expérience : <?= $perso->experience(); ?><br />
        Niveau : <?= $perso->level(); ?>
      </p>
    </fieldset>
 
    <fieldset>
      <legend>Qui frapper ?</legend>
      <p>
    <?php
    $persos = $manager->getList($perso->name());
 
    if (empty($persos))
    {
      echo 'Personne à frapper !';
    }
 
    else
    {
      foreach ($persos as $unPerso)
        echo '<a href="?frapper=', $unPerso->id(), '">', 
              htmlspecialchars($unPerso->name()), '</a> (dégâts : ', 
              $unPerso->damages(), ', expérience : ', $unPerso->experience(), 
              ', niveau : ', $unPerso->level(), ', force : ', $unPerso->strengh (),
              ')<br />';
    }
    ?>
          </p>
        </fieldset>
    <?php
    }
    else
    {
    ?>     
	<form action="" method="post">
          <p>
            Nom : <input type="text" name="nom" maxlength="50" />
            <input type="submit" value="Créer ce personnage" name="creer" />
            <input type="submit" value="Utiliser ce personnage" name="utiliser" />
          </p>
        </form>
    <?php
    }
    ?>
      </body>
    </html>
    <?php
    if (isset($perso)) // Si on a créé un personnage, on le stocke dans une variable session afin d'économiser une requête SQL.
    {
      $_SESSION['perso'] = $perso;
    }
    ?>

Lorsque j'affiche la page index.php, tout va bien. Par la suite, dès que je rentre le nom d'un personnage et que je le choisis pour jouer, j'ai l'erreur suivante qui s'affiche:

Code:

1
2
3
4
!) Remarque: Variable indéfinie: perso dans C: \ wamp \ www \ POO \ index.php à la ligne 49
Appelez Stack
#	Temps	Mémoire	Fonction	Emplacement
1	0,0007	157752	{principale}( )	... \ index.php : 0

Je comprends en elle même, mais ce qui me chagrine c'est que l'objet $perso je l'ai instancié à la ligne 31 de mon fichier index.php...

Peut-être pourrez-vous m'éclairer, car là j'avoue que je cale.

Merci d'avance :)