Reprise du message précédent :

le soufller n'est pas jouer  c'est à oublier je crois pas que ce soit une regle de base du jeu

 
c'est un truc auquel il faut que je pense c'est etudier les regle

Je crois que j'ai trouver les regles officiels ca m'arrange pas ca complique tout
 
http://membres.lycos.fr/nic55/dames/dames1.htm

Normalement je fais les dames se soir et demain je m'attaque a la partis la plus interessante L'ia
 
J'y connais rien mais ca devrait etre passionnant

je te confirme, ce sont les bonnes regles
par contre pr l'IA jepense pas que ce soit réalisable pi faut une sacrée réflexion...
je pense pas que php puisse gérer l'IA d'un tel jeu en terme de durée de recherche de coups(me rappelle d'un vieux jeu electronique ou l'IA cherchais tous les coups possibles pour chaque joueurs....
fait le jeu en duel par IP, doit etre plus sympa et + vite fait

 
  defetiste !!
 
Je pense developper une petite IA pas un bigblue !!  
 
Dans un permier tps le meilleur coup sans prévision
Dans un 2eme tps sur 2 ou 3 coup
 
Mais jouer par ip me semble aussi une bonne idée mais comment tu rafraichirais qd l'autre joueur a jouer ??

Une autre question j'aimerais changer l'image clicker pour suivre les coup jouer avant de valider mais j'y connais rien en javascript c'est possible car j'ai trouver juste le rollover

erf ca faut voir comment tu va gerer le deplacement des pions : comment en sélectionner un et dire qu'il va a tel endroit

 
bas ca c'est deja fait    
 
Je fait le deplacement du poin en clickant sur les images et j'incremante la variable choix que je decoupe ensuite pour modifier les valeur de mon tableau !
 
Le pb c'est pas dechanger le tableau entre les 2 ip mais de dire c'est bon j'ai jouer

Question sur les modulot
 
 if(($depart-$arriver)%9)==( 0))  
 
Ca veux bien dire que $depart-$arriver=0 ou 9 ou 18 ou -18 ou 9*n

KLeMix,
Je pensais à un truc pour pouvoir jouer à 2.
Pour faire le refresh automatique, est ce qu'il ne saurait pas possible de faire une boucle avec un wait dedans, qui intérroegerait la base.
Un truc du genre :
while($coup_adverse==0)
{
// T'intérroge ta base pour récupérer le champs $coup_adverse. Si l'aversaire a joué, son $coup_adverse==0 et le tient ==1
// Tu fais un Wait de 5 secondes
}
//Refresh de ta page

par contre ça je suis pas du tout d'accord...
je suis aussi en train de developer un jeu de strategie (a la mode MMO) avec un pote, et php est parfait...
simple, puissant...
 
Pour le jeu de dames, c'est pas non plus sorcier, suffit de mettre un refresh toutes les x secondes...

Ca me semble etre une bonne idée, mais je ne connais pas la fonction wait en php...
moi a votre place, j'aurais simplement fait un petit test : si l'adversaire a joué,
on refreshe la page tout de suite (donc echo 'code pour rafraichir la page de suite) else {'rafraichir dans X secondes en utilisant du javascript'}
 
Pour ton IA, ça va etre drole a développer, mais je suis d'avis que c'est loin d'etre impossible...
tu n'a qu'a commencer basiquement, l'IA fait des tests sur les X prochains coups pour voir comment elle fait pour manger le plus de pions...
Et pour les choix entre diverses actions, utilises des priorités , par ex:
manger un pion priorité 1
faire une dame priorité 5  
manger une dame priorité 8
perdre un pion priorité -1
perdre une dame priorité -5
 
Et la, il calculele coup suivant :
action possible 1 :je mange 3 pions ici et je perds mon pion, priorité 1+1+1-1=2 action possible 2 :je mange un pion ici et je fais une dame : priorité 5+1=6
priorité action 2> priorité action 1 donc je fais action 2...
 
le tout est de commencer simple je pense, pour faire evoluer ton IA au fur et a mesure...
pour faire varier le comportement de ton IA, utilise des random si plusieur actions ont la meme priorité, ou bien force la parfois a faire des trucs de priorité legerement plus faible que sa meilleure priorité pour la rendre plus imprevisible...

corrige ca sur ton site
 
J'ai developpé ce jeu de dames pour le plaisir et j'espère qu'il vous en procurera quand il sera fini. N'hésiter pas à me proposer un skin de votre création.

Up de la mort qui tue.
 
 
Version qui marche a peu près : http://jeux.dame.free.fr/
 
Bon j'ai envie de refaire mon jeux de dames en Objet.
 
La programmation Objet je sais plus ou mois faire. Mon souci c'est réfléchir en objet.
 
Faut que je refasse tout l'algo en objet et la je manque cruellement d'expérience.
 
J'ai fait une classe damier avec : un tableau que soit initialise soit je charge avec un code de parti. Mis a jour avec le chemin d'un pion : Ca marche
 
J'ai fait une classe joueur avec les code des pions, pion adverse dame et changement de joueur : Ca marche
 
J'arrive pas à voir comment faire une classe de déplacement ?
 
Elle aurait en paramètre : un chemin defini par l'utilisateur, le tableau en cours et le joueur en cours
On peut utiliser une classe dans une classe ?
 
Faut il que je pense autrement ?

Ouais, tu dois faire autrement
 
Les déplacements ne sont pas des objets, mais des comportements.
Autrement dit, des interfaces (PHP 5) et des traits (PHP 5.4).
 
Exemple :
 

interface MoveInterface { // On définit un comportement
  public function move();
}
 
trait Move { // On définit une implémentation du comportement
  protected $speed = 0;
  public function move() {
    return get_class($this).' moves at '.$this->speed.' km/h';
  }
}
 
abstract class Animal implements MoveInterface { // On utilise l'interface
  use Move; // On utilise une implémentation de l'interface 
 
  // Intéressant car on peut "implements" plusieurs interfaces 
  // et "use" plusieurs traits (séparation par des virgules), 
  // donc ce sont des morceaux de code réutilisables décentralisés
 
  // Tu n'es pas obligé d'utiliser des traits pour implémenter des interfaces
  // Tu peux les implémenter directement dans ta classe, mais c'est moins joli
  // sachant que tu ne peux hériter que d'une classe là où tu peux implémenter
  // autant d'interfaces que tu veux. Le couple interface / trait est donc une
  // solution élégante au problème d'héritage multiple
}
 
class Tiger extends Animal {
  public function __construct() {
    $this->speed = 50;
  }
}
 
$species = 'Tiger';
$animal  = new $species();  // Instanciate a new Tiger.
echo $animal->move();       // Display 'Tiger moves at 50 km/h'.
 
$animal = null;             // Free memory.
gc_collect_cycles();

 
Tu dois aussi faire une classe Pion, sachant que ta classe Damier doit contenir une liste / un tableau de pion
Pour le stockage des coordonnées, tu as vaguement trois options :
- Laisser le damier décider
- Stocker les coordonnées x,y dans le pion
- Stocker une référence au Damier dans le Pion (on peut demander au pion ses coordonnées, mais la logique reste au niveau du damier et en fait c'est lui qui va faire tout le boulot de recherche. Attention aux références circulaire et à bien mettre le Damier du Pion à null dans son __destruct)
 
Ce qui basiquement donnerait (j'ai pas traduit le nom des classes et le code est grossier)  
 

class Damier {
 
  protected $a = array();
 
  public function __construct() {
    for ($i = 0; $i < 50; ++$i) {
      for ($j = 0; $j < 50; ++$j) {
        
        $player = new Player();
        $player->setId(1);
        $player->setIA(true);
 
        $pion = new Pion();
        $pion->setDamier($this);    // Optionnel selon la stratégie choisie
        $pion->setPlayer($player);
 
        $this->$a[$i][$j] = p;
 
      }
    }
  }
}

je vais etudier les interfaces, je pense que c'est effectivement cstte notion qui me manque.
 
Merci,  
Je vous tiens au courant des avancés

Dans ton exemple, je joue un coup, le player change de main, comment je fait pour utiliser les méthodes de Player dans la classe Damier ?

Ca : $this->player->changeJoueur();
C'est pas bon

si ca marche en faite ²

Pourquoi ca ca marche :
 
class o_damier  
    {
        private $tab_damier ;
        private $code_init;
        private $player;
        public function __construct()
        {
            $this->tab_damier = array( ) ;
            $this->code_init = '2-1-20A10C20B';
            $this->loadDamier($this->code_init);
            $this->player = new o_joueur('Player');
            echo 'test :'.$this->player->nom_joueur();
        }
        public function LoadJoueur($joueur)
        {
//         echo $this->player->nom_joueur();
}
}
 
et pas ca :
 
 
class o_damier  
    {
        private $tab_damier ;
        private $code_init;
        private $player;
        public function __construct()
        {
            $this->tab_damier = array( ) ;
            $this->code_init = '2-1-20A10C20B';
            $this->loadDamier($this->code_init);
            $this->player = new o_joueur('Player');
 
        }
        public function LoadJoueur($joueur)
        {
         echo $this->player->nom_joueur();
}
}
 
 
-> Fatal error: Call to a member function nom_joueur() on a non-object

Essaye de faire un var_dump sur $this->player avant d'afficher le nom, mais à priori elle n'est pas initialisée, ou en tout cas pas à une instance de o_joueur

tu as raison  
        public function LoadJoueur($joueur)
        {
         var_dump($this->player);
//         echo $this->player->nom_joueur();
//         $this->player->setJoueur($joueur);
        }
 
me donne null
 
Pourquoi le $this->player = new o_joueur('Player'); dans le  __construct()  n'instancie pas l'objet ?

A priori il l'instancie puisque que dans ton exemple précédent le "echo 'test'" fonctionne.
 
Il faudrait faire un var_dump à chaque étape tu manipules le $this->player entre les 2 pour voir où ça coince.

le var_dump dans le contruct fonctionne.
si je met les 2. J'ai les def + variable, et NULL

Boulet mode !!!
 
 
            $this->loadDamier($this->code_init);  
            $this->player = new o_joueur('Player');  
 
la fonction LoadJoueur($joueur)  est appeler dans loadDamier et donc player n'est pas instacier !

C'est dans ces moments qu'un débugger est pratique

Bon mes 2 classes principales sont faites je vais pouvoir attaquer les interfaces de mouvements

Comment je force le PHP 5.4 chez free ?
 
Sinon j'ai pas compris l’intérêt des interface sans le trait ?

1] J'en sais foutrement rien, je suis en dédié, donc j'installe ce que je veux comme je veux pour 15 €/mois
 
2] Tu as plusieurs possibilités, voilà un exemple de cheminement :
 
Faire des héritages de classes
 
class A {}
class B extends A {}
 
Mais dès que tu veux faire un
 
class A {}
class B {}
class C extends A,B {}
 
Tu peux pas, car l'héritage multiple est interdit.
C'est une bonne pratique qui évite de se retrouver avec des conflits de méthodes qui avaient le même nom dans A et B.
C'est aussi un reliquat de C++ (Rappel : PHP est écrit en C++).
 
Tu vas donc passer par des interfaces.
Une interface t'engage à écrire à un moment donne une implémentation du code (tu auras une erreur si tel n'est pas le cas)
 
interface A {}
interface B {}
class C implements A,B {}  
 
La caractéristique des interfaces, c'est qu'elles ne contiennent que des méthodes virtuelles pures, c'est à dire dépourvues d'implémentation.
Ce sont juste des définitions (bien pratique pour voir clairement ce que fait ton objet et quelles méthodes sont disponibles)
On ne voit de fait que des signatures de méthodes.
 
Tu peux alors adjoindre à ces interfaces une classe ou un trait pour l'implémentation.
Si tu choisis une classe, il est préférable d'utiliser une classe abstraite : pas de possibilité de l'instancier directement avec un new, on s'en sert juste pour la hiérarchie de classes.
 
interface A {}
abstract class AA implements A {}
class B extends AA implements A {}
 
$aa = new AA(); // Erreur
$b   = new B();  // OK
 
Mais du coup tu te retrouves avec le travers de ne pouvoir étendre qu'une seule classe. Or la plupart du temps tu veux implémenter plusieurs comportements, métiers ou non métier, comme un enregistrement en base, qui n'a rien à faire dans une hiérarchie de classes. Du coup ça devient bricolo, car tu fais des héritages de trucs qui n'ont rien à voir, ou alors tu implémentes le tout directement dans ta classe finale pour satisfaire l'interface mais tu perds l'intérêt de la séparation du code.
 
Exemple de sémantique pourrie ante-PHP 5.4 (pas le choix)
 
abstract class DatabaseObject {}
abstract class Animal extends DatabaseObject {}
class Tiger extends Animal {}
 
On propage certes les propriétés d'auto enregistrement en base sur tous les animaux, mais on détruit complètement la sémantique.
Un Tigre est un Animal. Mais un Animal n'est pas un putain d'objet de base de données, ça c'est un comportement.
Et donc avant PHP 5.4, tu faisais des tas d'héritages (un par comportement) et tu te retrouvais avec des hiérarchies insensées sur X niveaux.
Ça fonctionne, mais c'est du grand n'importe quoi.
 
Alors qu'avec les traits tu es beaucoup plus souple pour séparer ton code, ça ajoute un niveau de granularité très appréciable :
 
interface A {}
trait AA {}
interface B {}
trait BB {}
abstract class C implements A, B {use AA, BB;}
class D extends C {}
$d = new D();
 
Et surtout, tu places les traits uniquement dans les classes qui en ont besoin.
Alors qu'avec la méthode old school toutes tes classes héritaient obligatoirement de tous les comportements même si seulement quelques unes en avaient besoin.
Ouais, avant on codait vraiment comme des moches.
 
En définitive, tu peux utiliser les traits sans interface et vice versa, mais ils sont vraiment faits pour fonctionner ensemble.
 
Si on résonne avec un restaurant, tu peux voir une interface comme une ligne du menu à la carte, et un trait comme le plat physique y afférant.
La classe abstraite représente alors une composition de plats, une recette ou une formule (il y a cette notion d'agrégat), et la classe la transposition de la formule dans le monde réel, c'est à dire les différents plats que tu vas déguster.
 
interface SaladeTheorique {}
trait SaladeReelle {}
interface SteakTheorique {}
trait SteakReel{}
abstract class MenuDuMidiTheorique implements SaladeTheorique, SteakTheorique {use SaladeReelle, SteakReel;}
class MenuDuMidiReel extends MenuDuMidiTheorique {}
$m = new MenuDuMidiReel();
 
Sachant que tu peux avoir d'autres menus qui utilisent aussi de la salade, du steak... bref tu réutilises un peu tes composants comme tu veux.
 
Donc pour répondre à ta question, les traits, c'est TRES élégant.  
 
Bref, j'espère avoir été clair !  

Bon apparament chez free le 5.4 c'est pas pour tout de suite donc les traits c'est mort.

D'apres se que j'ai compris les interfaces ( sans les traits) c'est juste des contraintes pour avoir code plus claire

Si j'ai bien compris mon exemple serait :

interface calcule
{
public function addition
public function soustration
public function multiplication
public function soustraction
}

class caculatriceBasic implements calcule

class calculatriceScientifique implements calcule

Cela oblige tes 2 classes a avoir des opération de calcule.

Mais sans les traits tu es obligé de faire 2 fois les fonctions dans 2 les classes.

J'ai bon ?

Ouais t'as bon !
 
Soit tu implémentes direct dans les calculatrices avec la redondance que ça implique (à toi de voir combien de fois tu vas redonder ton code), soit tu implémentes le code commun dans une abstract class, et tes deux calculatrices en héritent.  
 
interface calculInterface {
  public function addition($a , $b);
  public function soustration($a , $b);
  public function multiplication($a , $b);
  public function division($a , $b);
}
 
abstract class calcul {
  public function addition($a , $b) {
    // ...
  }  
  public function soustration($a , $b) {
    // ...
  }
  public function multiplication($a , $b) {
    // ...
  }
  public function division($a , $b) {
    // ...
  }
}
 
class calculatriceBasic extends calcul implements calculInterface {
}
 
class calculatriceScientifique extends calcul implements calculInterface {
  function sinus($a) {
    // ...
  }
  function cosinus($a) {
    // ...
  }
  function tangente($a) {
    // ...
  }
}
 
$b = new calculatriceBasic();
$s = new calculatriceScientifique();
 
$b->add();
$s->add();

J'ai l'impression que le clone me fait pas une copie de l'objet mais juste une duplication de nom de variable
 
$a = clone $b;
me donne le même résultat que
$a=$b;
 
c'est a dire
$a->nom_jour('IA');
$b = clone $a;
$b->changejoueur(); // aucune variable static
$a->getjoueur() // me donne Humain
 
C'est normal ?

Nan c'est pas normal du tout !
 
Sauf si tu utilises des références comme dans ce post :
http://www.php.net/manual/fr/langu [...] php#106135
 
Mais dans ce cas là tu overriderais volontairement le cloning.

J'ai pas encore fait les mouvements IA de dame mais l'IA commence a être dure a battre

Version objet : http://klemix.free.fr/dame/

Question :
 
Mon IA triche quand elle a plusieurs chemins d'atttaque.
Dans les fonctions récursives y a des méthodes pour débugger simplement ?
 
L'affichage de variable devient vite ingérable :s
 
Pour info je developpe sous ultraEdite

Bon j'ai finis (reste de la cosmétique a faire)
 
Vous pouvez faire une partie ou 2 pour tester et me donner votre avis ?
 
http://klemix.free.fr/dame
 
Merci  
 
Ps: pour les ano pas besoin de faire un ticket juste un petit poste ici

salut klem, tu le dev encore ? c'est open source?
 
j'ai testé, mais je sais pas si c'est un bug ou pas, mais faut cliquer sur "jouer" pour l'IA ?