Discussion :

[Sereine]

Bonjour à tous. J'ai pas une grande expérience dans le domaine du développement web, ça fait seulement depuis quelques temps que je touche au php objet avec Zend.
Pour pousser un peu plus loin mes connaissances, (et de toute manière c'était un projet que j'avais en tête), je me suis mise sur un petit projet de jeu php, toujours sous zend.

Je veux progresser et programmer proprement, ayant beaucoup de mal avec la conception purement objet (bah oui, à l'école ils nous apprennent ça en dernier et à la volée ..) je me suis tourné vers les tuto.

Alors les tuto c'est beau, mais, la plupart des tuto que je croise ne sont pas suffisamment poussé. Du coup il y a certains aspects sur lesquels je bloque.

Voilà pour l'explication.

Le problème actuel:

mon jeu web comporte pas beaucoup de fonctionnalité pour le moment, seulement l'essentiel:
création de personnages, combat d'un monstre, tout ce qui concerne la gestion du combat (perte de point de vie/gain d'exp, ect ...)

J'en viens maintenant à la création d'items et de l'inventaire.

Actuellement j'ai deux classes: Personnage et Monstre.
Ce sont deux objets qui me paraissent logique.

En revanche, lorsque j'en viens à l'inventaire, je perds un peu pied, .. Dois je créer une classe inventaire? qui serait entremêlé avec la classe personnage?
J'arrive à peu près à le concevoir, en revanche, en ce qui concerne les items, par exemple une potion de vie contenu dans l'inventaire,
je dois concevoir une classe également?

Si quelqu'un pouvait débrouiller tout ça avec des exemples simple pour m'aider à comprendre, se serait gentil

[grunk]

Actuellement j'ai deux classes: Personnage et Monstre.

Qui doivent très probablement pouvoir dériver d'une même classe puisque un personnage et un monstre on probablement pas mal d'attribut en commun.

Dois je créer une classe inventaire? qui serait entremêlé avec la classe personnage?

Une classe inventaire me semble pertinente , on peut imaginer quelque chose comme ça qui dérive de SPl ObjectStorage pour une gestion simplifié des objets contenu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
class Inventaire extends SplObjectStorage
{
    private $maxSize = 10;
 
    public function attach(Item $item,$data = null)
    {
        if(!$this->isFull)
	    parent::attach($item,$data);
    }
 
    public function detach(Item $item)
    {
        parent::detach($item);
    }
 
    public function hasItem(Item $search)
    {
        return $this->contains($search);
    }
 
    public function isFull()
    {
	return $this->count() >= $this->maxSize;
    }
}

Note : Le type hint Item peut lever un warning Strict Standard si le bug à toujours pas été corrigé coté php.

A celà tu ajoute une classe "Item" générique à tous tes type d'objet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class Item
{
    private $name;
    private $properties;
    private $type;
 
    public function __construct($name,$type,$prop)
    {
	$this->name = $name;
        $this->type = $type;
	$this->properties = $prop;
    }
}

Lorsque tu créer un personnage tu crée également un inventaire que tu lui passe via son constructeur ou un setter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$inventaire = new Inventaire();
 
$perso = new Personnage('Jean','bon');
$perso->setInventory($inventaire);

Et quand tu as besoin d'ajouter un objet dans l'inventaire tu fait simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$potion = new Item('potion de vie',Item::CONSOMMABLE,array('prix' => 100, 'energie' => 500));
$perso->getInventory()->attach($potion);

Pour comprendre SPLObjectStorage voir la doc PHP ou cet article

[Celira]

Personnellement, je vois ça comme ça : ton Personnage transporte des Items dans son Inventaire.
Personnage est un objet qui représente le personnage.

Item est un objet qui représente un item. Si tu as plusieurs types d'item, tu peux avoir des objets héritant d'Item. Par exemple, Potion est un Item. Tu peux aussi avoir un objet Equipement (qui est un Item) qui correspond aux éléments d'équipement et avoir une classe Arme qui hérite de Equipement...

Pour l'inventaire, je dirais que ça dépend de comment tu conçois ton inventaire : est-ce que c'est juste un gros sac avec tout en vrac dedans ? ou est-ce que c'est un truc élaboré qui gère les potions d'un côté, les équipements de l'autre ?

EDIT : ah tiens, je connaissais pas SplObjectStorage, ça a l'air pratique comme truc...

[Sereine]

Ah superbe merci.

En faite l'inventaire est juste un gros sac. Il peut contenir plusieurs items.
SplObjectStorage a l'air d'être tip top pour ça, j'avais du mal à voir comment j'allais pouvoir lister tous les objets de mon inventaire, mais là ça a l'air plus simple avec ça.

Bon je vais essayer de faire tout ça proprement ^^

Edit:
Voilà ce que j'ai fait, simplement pour afficher mon inventaire.
Je sais pas si c'est correct ou non (bien que ça marche correctement)
En gros, dans mon controller je fais pas grand chose, j'appel 2 fonctions de mon model.
Le model va me servir à faire le lien entre la construction des objets et la base de donnée.
Il va donc chercher si il a besoin, la ligne qu'il lui faut dans la base de donnée, et la retourne sous forme de tableau. Mon objet va se créer à partir du tableau automatiquement.
Ma base de donnée se constitue comme ceci:

Item = répertorie tous les items existants et circulant dans le monde, donc chaque item crée, droper, s'ajoute dans cette table.
Item_proto = inventaire de tous les items avec leurs attributs basiques
Player_inventory = inventaire des joueurs, répertorie chaque Item et l'associe à un inventaire
Player = personnage avec toutes ses caractéristiques

Donc le controller qui va faire afficher mon inventaire (enfin un bout du controller:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$Personnage = new Home_Model_DbTable_Personnage();
$Inventory = new Home_Model_DbTable_Inventory();
$perso = $Personnage->getPlayer($this->perso_exist);
$player_inventory = $Inventory->getInventory($perso->id());
$this->view->items = $player_inventory;

Le morceau de model Personnage qui va interagir

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class Home_Model_DbTable_Personnage extends Zend_Db_Table_Abstract {
 
    protected $_name = 'player';
    protected $_primary = 'id';
 
public function getPlayer($id_player) {
        if (is_int($id_player)) {
            $arrayPlayer = $this->fetchRow($this->select()->where('id = ?', $id_player))->toArray();
 
            return new Personnage($arrayPlayer);
        } 
    }
}

Le model Inventory:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class Home_Model_DbTable_Inventory extends Zend_Db_Table_Abstract {
 
    protected $_name = 'player_inventory';
    protected $_primary = 'inventory_id';
 
   public function getInventory($id_player) {
        if (is_int($id_player)) {
            $arrayInventory = $this->fetchAll($this->select()->where('player_id = ?', $id_player));
            $ItemModel = new Home_Model_DbTable_Item();
            $ItemProtoModel = new Home_Model_DbTable_ItemProto();
            $storage = new Player_Inventory();
            foreach ($arrayInventory as $inventory) {
                $item = $ItemModel->getItem($inventory->item_id);
                $nom = $ItemProtoModel->getItemProto($item->item_proto_id());
                $item->setNom($nom->name);
                $storage->attach($item);
            }
            return $storage;
        }
    }
}

(bon le model ItemModel va créer un objet item comme pour le model personnage, et ItemProtoModel va juste retourner la ligne de l'item_proto correspondant)

La classe inventory est la même que celle que vous m'avez montré, en dehors d'une petite correction sur if(!$this->isFull()), manquait les parenthèses

Pour mes classes je les construit comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
class Item {
 
    private $_item_id;
    private $_item_proto_id;
    private $_stack;
    private $_bonus_1;
    private $_value_bonus_1;
    private $_nom;
 
    public function __construct(array $donnees) {
        $this->hydrate($donnees);
    }
 
    public function hydrate(array $donnees) {
        foreach ($donnees as $key => $value) {
            $method = 'set' . ucfirst($key);
 
            if (method_exists($this, $method)) {
                $this->$method($value);
            }
        }
    }
 
    public function item_id() {
        return $this->_item_id;
    }
 
    public function item_proto_id() {
        return $this->_item_proto_id;
    }
 
    public function stack() {
        return $this->_stack;
    }
 
    public function bonus_1() {
        return $this->_bonus_1;
    }
 
    public function value_bonus_1() {
        return $this->_value_bonus_1;
    }
 
    public function nom(){
        return $this->_nom;
    }
 
    public function setItem_id($id) {
        $id = (int) $id;
 
        if ($id > 0) {
            $this->_item_id = $id;
        }
    }
 
    public function setItem_proto_id($id) {
        $id = (int) $id;
 
        if ($id > 0) {
            $this->_item_proto_id = $id;
        }
    }
 
    public function setStack($exp) {
        $exp = (int) $exp;
        $this->_stack = $exp;
    }
 
    public function setBonus_1($life) {
        $life = (int) $life;
 
        $this->_bonus_1 = $life;
    }
 
    public function setValue_bonus_1($lvl) {
        $lvl = (int) $lvl;
        $this->_value_bonus_1 = $lvl;
    }
 
    public function setNom($nom){
        $this->_nom = $nom;
    }
 
}