Aide et renseignement combat php

[dobi19]

Bonjour à tous,

je suis nouveau sur ce forum qui m'a l'air très sympathique et j'aurais besoin d'un petit peu d'aide car en ce moment j'essaie de faire un petit jeu en PHP et Flash.

Pour résumer le principe, un joueur s'inscrit, ensuite il joue à un des jeux proposés en flash et chaque partie joué est enregistré dans ma BDD pour cela pas de soucis, j'ai mis un peu de temps mais j'y suis arrivé.

Du coup je récupère l'id de la partie jouée, l'id du joueur et le score de la partie.

En revanche, j'aimerais faire en sorte que les joueurs jouent les un contre les autres, donc je me suis dit ce serait bien qu'après chaque partie, je traite la partie qui vient d'être joué dans une sorte de "combat" au final, le gagnant gagne 2 points, le perdant rien du tout...

Mais du coup je me perd un peu dans ma logique (pour m'expliquer aussi...) pour créer une nouvelle table par exemple la nommé "combat" et pareil pour tout ce qui est condition etc... Dans le traitement du combat.

Parce que j'aimerais aussi y intégrer une condition dans le choix des adversaires en fonction de leurs niveaux de points du coup...

Je voudrais savoir si vous auriez connaissance de tutoriel ou script partant de ce principe, afin de pouvoir l'étudier et pourquoi pas le modifier afin de l'adapter à mon jeu pour voir ce que ça donne.

Merci d'avance pour vos futurs réponse.

[MicroNotSoft]

Bonjour,

au final quelle est ta demande ?

Le combat que tu aimerais généré est un combat tour par tour, ou bien tu opposes deux joueurs et selon leurs caractéristiques respectives tu en déduis un vainqueur ?

Pour base, je partirais sur ceci :

Table combats :
- id
- id_joueur
- id_adversaire
- resultat (1 = joueur gagne, 0 = adversaire gagne)

Tu as ainsi les deux adversaires et selon le résultat tu peux savoir qui a gagné le combat et donc les 2 pièces.

[Xenos]

Oui, c'est vrai que là, la question est plutôt du ressort de la conception: il n'y a donc pas de bonne réponse, c'est simplement à toi de choisir quel sera l'enchainement d'actions pour faire ces combats.

Après, il se peut que les joueurs qui viennent actuellement sur ta plateforme de jeu aiment le coté "immédiat et éphémère" des jeux flash: si tu les oblige à faire des combats et à avoir des résultats qui durent dans le temps (le nombre de "combats" gagnés par exemple), alors tu décevra peut-être une partie de ces joueurs qui ne verra plus le coté "jeu flash éphémère à jouer juste 5 minutes entre deux cours"...

[dobi19]

D'accord je vois, oui c'est bien sa j'oppose deux joueurs selon leurs caractéristiques respectives et j'en déduis un vainqueur en comparant leurs scores.

Donc du coup dans id_joueur et id_adversaire je récupère les id des parties et selon le résultat j'update le nombre de point au joueur.

Par contre comment j'automatise le cycle des combats, sous forme de boucle?

Parce que admettons si j'ai 4 joueurs différents qui jouent chacun une partie.

ça donnerait par exemple:

Partie 1 vs Partie 2 = 1 id combat
Partie 3 vs Partie 4 = 1 nouveau id combat
etc.. au fur et a mesure.

Ce que je demande en fait, c'est comment je peux m'y prendre pour arriver à tous ça
en même temps ça fait du bien de poser le problème et d'en parler, pour mieux voir les choses.

[MicroNotSoft]

Apparemment tu utilises le mot "Partie" pour parler d'un joueur. Pourquoi ne pas simplement parle de joueur ?

En fait tu ne dois même pas récupérer quoi que ce soit pour mettre à jour le nombre de points du vainqueur.

Joueur 1 et Joueur 2 ne vont s'affronter que si Joueur 1 clique sur "Combattre".
Dès lors tu utilises ton petit algorithme afin de déterminer le résultat.
Tu stockes dans la table combat, les ids des deux joueurs et le résultat.
Ensuite, si le résultat = 1 tu ajoutes 2 pièces au Joueur 1, sinon tu ajoutes 2 pièces au Joueur 2.

Tu n'as pas de boucles dans ce cas car le combat est déclenchée par une action du côté utilisateur.

[dobi19]

Ok, c'est pas faux je vais utiliser le mot joueur

Oui en fait je fait une différence entre le score et les points, pour moi les points ce sont tes pièces et le score tes points.

Mais comme tu dis, si le joueur clique sur combat joueur 1 et 2 vont s'affronter, admettons que le joueur 1 clique sur combat,
il crée un nouvelle id_combat et incrémente l'id_joueur, comment on défini id_adversaire ?

Parce que du coup tout le monde est id_joueur ?

Je vois pas trop, parce que en fait c'est un combat oui et non dans mon cas, car par exemple un joueur va faire une partie de tétris et faire tel score "points" la partie pour lui est fini. Et plus tard 1,2,5 ou 10 minutes après quand un autre joueur arrive et décide de faire un tétris, hop il joue sa partie et ce serait la que leurs score "points" serait comparé. (chaque joueur joue sa propre partie en solo au final... Et ce n'est qu'après, aléatoirement on peut dire, qu'un "combat" est créé)

Je suis vraiment désolé si je ne suis pas très claire...

[MicroNotSoft]

Ok je vois un peu mieux ce que tu veux.

Voici comment ta table combat doit être formée, au minimum.

Code :

id
id_joueur (id du joueur qui défie)
id_adversaire (id du joueur défié)
resultat (0 = joueur perd, 1 = joueur gagne, 2 = égalité)
joueur_score (score du joueur)
adversaire_score (score de l'adversaire)
joueur_a_joue (0 = joueur a pas encore joué, 1 = joueur a joué)
adversaire_a_joue (0 = adversaire a pas encore joué, 1 = adversaire a joué)

Donc quand Joueur 1(id = 1) défie Joueur 2 (id = 2), cela crée un enregistrement avec simplement les identifiants de ces deux joueurs dans la table combats.

Code :

id_joueur = 1
id_adversaire = 2

Ensuite, joueur 1 va jouer la partie de tetris. Admettons qu'il fasse 2000 points.

Tu vas donc ajouter cette valeur dans ton combat.

Code :

joueur_score = 2000
joueur_a_joue = 1

Ensuite, 2 heures après, joueur 2 se connecte et voit qu'il a encore un défi auquel il n'a pas joué, il joue et fait 1300 points.

Tu vas donc ajouter cette valeur dans ton combat.

Code :

adversaire_score = 1300
adversaire_a_joue = 1

Maintenant tu sais que les deux joueurs ont terminé le défis, car joueur_a_joue = 1 et adversaire_a_joue = 1 aussi. Tu peux donc déterminer le résultat et le stocker (ce n'est pas nécessaire de le stocker, mais disons que c'est plus simple par après).

Code :

Si joueur_score < adversaire_score
  resultat = 0
  Ajouter la récompense à joueur
Sinon si joueur_score > adversaire_score
  resultat = 1
  Ajouter la récompense à l'adversaire
Sinon
  resultat = 2
  Ajouter une demi récompense aux deux
Fin Si

[dobi19]

Merci beaucoup ça commence à devenir limpide

Juste un détail c'est par rapport à quand Joueur 1(id = 1) défie Joueur 2 (id = 2), c'est pas tout à fait défier au sens propre.

En fait ce serait plutôt:

Quand Joueur x(id = x) défie Joueur x (id = x)

Parce que j'avais pensé a faire pareil que ton exemple, mais le soucis c'est que si le Joueur 2 ne revient plus jamais sur le jeu, le défie reste à l’abandon.

Je préférais que les combats se crée au fil des parties jouée par les membres, si tu vois à peu près ce que je veux dire, comme ça personne n'attend vraiment et au fur et à mesure ça continu.

Exemple:

Sur une période d'une heure chronologiquement sur ce laps de temps, chaque joueurs fait une partie de tétris:

Joueur 4 (id = 4)
Joueur 12 (id = 12)
Joueur 7 (id = 7)
Joueur 27 (id = 27)
Joueur 18 (id = 18)
...

De ses parties la y faudrait obtenir:

Joueur 4 (id = 4) VS Joueur 12 (id = 12)
Joueur 7 (id = 7) VS Joueur 27 (id = 27)
Joueur 18 (id = 18) VS En attente...

Et la quand un Joueur x (id = x) n'importe lequel, se décidera à faire une partie, hop ça complétera le troisième combat, et ainsi de suite...

Après tout le reste ça va, j'ai saisis et pour classer les combats par niveau des joueurs je rajouterais un champ et une condition.

Y reste que ce petit soucis, ou la je vois pas du tout, merci encore en tous cas!

[MicroNotSoft]

Je suis pas forcément emballé par ce que tu proposes, si tu souhaites faire des rencontres aléatoires tu peux le faire également. Sinon pour pallier au problème de parties abandonnées, il suffit de donner une durée de vie à tes défis. Si tu dis qu'un défi dure maximum 3 jours, lorsque tu crées un combat, tu lui donne la date et l'heure actuelle, et puis tu fais un cron ou simplement une fonction quelque part dans ton code qui vérifie si il y a des défis en attente de plus de 3j et de les nullifier (soit tu déclares le joueur qui a défié vainqueur, soit tu annules ou supprimes simplement le combat).

Cette solution est utilisée par pas mal de jeux sur Facebook dont SongPop. Tu peux défier tes amis inscrits à SongPop ou bien chercher des adversaires aléatoirement.

Ceci dit je suis pas là pour juger Donc voici comment tu pourrais solutionner ton problème :

Dans la réalité ce qu'il se passe :

Code :

Joueur 1 lance une partie
Joueur 3 lance une partie
Joueur 4 lance une partie
Joueur 2 lance une partie

Point de vue du code :

Joueur x (peu importe qui et quand) lance une partie à un moment x.

Code :

Vérifier si il y a un combat où id_joueur est différent de id Joueur x ET où id_adversaire est NULL (1ère condition pour éviter de jouer contre soi-même, 2ème pas encore trouvé d'adversaire).
Si non :

  Créer un combat avec id_joueur = id du Joueur x [id_adversaire est laissé à NULL (car on ne sait pas contre qui on va jouer)]
  Faire jouer Joueur x
  Mettre le score de Joueur x dans score_joueur
  
Sinon :

  Le combat que l'on va compléter est le premier combat dans la base de données où l'id_joueur est différent de l'id de Joueur x et que l'id_adversaire est NULL.

  Mettre l'id du Joueur x dans id_adversaire.
  Faire jouer Joueur x
  Mettre le score de Joueur x dans adversaire_score

  Calculer et stocker le résultat (comparer le score_adversaire et score_joueur pour définir qui a gagné)
  
  Si résultat = 1 -> id_joueur (Joueur y qui avait joué et créé le défi juste avant que Joueur x joue) a gagné
  Si résultat = 0 -> id_adversaire (Joueur x) a gagné
  Si résultat = 2 -> les deux joueurs sont a égalité

Fin si

[dobi19]

En effet, c'est pas bête du tout, concilier les deux serait plus sympas, défie aléatoire et par défie par choix.

Si tu veux dans mon esprit je m'étais fixé l'aléatoire, comme si je le met en ligne, j'aurais pas forcément un trafic important
du coup c'était pour palier ce problème d'attente.

Pour le moment je vais intégrer l'aléatoire puis ensuite défie par choix.

Merci sincèrement pour ton aide MicroNotSoft

Je vous tiens au courant.