Tituc

 tutoriel / partage [JAVA/PHP - MySQL] Un classement quotidien

Recommended Posts

Attention :

- Dans ce tutoriel, l'émulateur montré pour la modification sera AR54.

- Lors de la modification dans la base de donnée, le serveur doit être Hors Ligne (Realm et Game).

- Pour que ce classement fonctionne correctement, le serveur doit en fonctionnement 24/24H (sauf maintenance ou simple redémarrage). Si votre serveur est chez-vous et que maman ou papa veut l'arrêter tous les soirs à 22h, ce tutoriel n'est pas fait pour vous.

- Ce tutoriel risque de vous paraître assez long, il est conseillé de prendre un petit café.

- La variable BDD_NOM est la même que DB_NAME

- Ne gueulez pas, j'ai conscience d'avoir repris le code d'un classement dont je ne connais pas l'auteur pour la partie en PHP.

 

Coucou,

 

Comme en témoigne l'aide psychologique offerte à Nicky, les tutoriels que je propose (comme celui-ci) peuvent avoir des codes qui ne sont pas très optimisés. Ceci peut engendrer dépressions ou/et comportements dangereux chez certains développeurs sensibles. Si vous avez des solutions pour optimiser les codes proposés, ou régler d'éventuelles failles (on ne sait jamais), vous pouvez toujours proposer votre solution.

 

Petit résumé de ce tutoriel :

 

Lors de ce tutoriel, il sera montré comment faire un classement, mais pas n'importe lequel ! Il s'agira d'un classement qui classera l’expérience gagnée en 24H avec un petit record du bonhomme qui aura gagné le plus d'expérience en 24H (ce record ne sera pas remis à zéro). Ce classement se remettra donc à zéro toutes les 24H et ceci même si le serveur redémarre, attention cependant : Une maintenance trop longue peut quand même dérégler ce petit classement (si vous faites une maintenance, ne la faites pas à minuit, nous verrons pourquoi plus bas.)

 

Petit détail :

Petit détail

Lors de ce tutoriel, une nouvelle table sera créée, celle-ci enregistrera l'expérience gagnée avec le record en 24H. Ne soyez donc pas étonné des nombreuses modifications à savoir un chargement de ces stats, une sauvegarde, etc..

 

Voici lien pour que vous pussiez voir brièvement le résultat :

 

http://www.winedowze.com/winedowze/1.29/index.php?page=classements/ladderPVM24h

 

Pour ceux qui ont une petite flemme d'aller sur le lien, voici une capture d'écran :

 

 

Bien évidemment, dans ce tutoriel je ne présenterai pas la fonction de recherche de personnage (pour ceux qui sont allé sur le lien).

 

Les modifications nécessaires pour faire ce tutoriel sont :

- En JAVA :

common : Ancestra.java, SQLManager.java

game : Classements.java

objects : Action.java, Fight.java, Personnage.java

- En SQL :

Table 'stats_combats' concernée

- En PHP :

Fichier ladderPVM24h.php

 

Rouge : Ce qui sera créé dans ce tutoriel

Vert : Ce que vous devez déjà avoir

 

Sur ce classement, 3 caractéristiques différentes seront exploitées :

- Le gain d'expérience en 24h

- Le record d'expérience en 24h

- Le nom du personnage

 

Il est bien évidemment possible d'afficher plus de caractéristiques, mais j'ai préféré faire comme ça (disons que c'est plus facile étant donné que l'expérience gagnée en 24h sera dans une nouvelle table).

 

Pourquoi créer une nouvelle table ?

 

Il est vrai qu'on aurait pu mettre l'expérience gagnée dans la table 'personnages' (ce qui l'aurait un peu surchargé, à la fin on a du mal à s'y retrouver si on met tout au même endroit) mais me concernant et je pense que certains penseront pareil, j'ai créé cette nouvelle table pour rassembler toutes les caractéristiques concernant les combats (points de kolizeum ou compteur de monstres tués par exemple), et c'est bien mieux que de tout tasser dans la table 'personnages'.

 

 

Modification en JAVA :

 

Principe :

Nous allons commencer par créer le fichier Classements.java (je l'ai au pluriel car je possède plusieurs types de classements, mais mettez au singulier si ça vous gène). Pour créer ce fichier, je me suis inspiré du fonctionnement de GameServer.java. Un timer sera donc lancé à chaque lancement de l'émulateur et vérifiera l'heure actuelle (vérification réglée à une fois par heure).

 

C'est tout simple :

Si il est minuit, on remet à zéro le classement.

 

Application :

On va tout d'abord créer le fichier Classements.java dans la partie game. Vous vous retrouvez donc avec une magnifique page blanche. On commence par importer les éléments nécessaires pour cette page :

package game; 

import java.util.Calendar; 
import java.util.Timer; 
import java.util.TimerTask; 
import objects.Personnage; 
import common.*;

 

Ceci permettra de connaître l'heure actuelle (java.util.Calendar), de faire fonctionner le timer (java.util.Timer/TimerTask), et de pouvoir remettre à zéro l'expérience gagnée en 24h sur les joueurs connectés. En dessous, on crée les variables nécessaires :

private Thread _t; 
private Timer _Classement24hPVM;

 

Rien de compliqué ici (on définira également une variable plus tard dans Ancestra.java, celle-ci définira le temps entre deux vérifications de l'heure actuelle pour remettre le classement à zéro). La suite, on ajoute :

public Classements() 
{ 
	_Classement24hPVM = new Timer(); 
	_Classement24hPVM.schedule(new TimerTask() { 
		public void run() 
		{ 
			Reset24HPVM(); 
		} 
	}, Ancestra.CONFIG_RAPPEL_LADDER, Ancestra.CONFIG_RAPPEL_LADDER); 
	_t = new Thread(); _t.start(); 
}

 

Voici cette fameuse variable non définie pour le moment (CONFIG_RAPPEL_LADDER) donc si vous avez une erreur dessus, c'est normal pour le moment puisqu'on la définira plus tard. Le code ci-dessus sert donc à remettre à zéro le classement.

 

Attention : Sachez que la remise à zéro du classement n'impliquera pas une remise à zéro du record. Logique.

 

On continue en ajoutant :

public static void Reset24HPVM() 
{ 
	if (Calendar.getInstance().get(Calendar.HOUR_OF_DAY) == 0)
	{ 
		SocketManager.GAME_SEND_Im_PACKET_TO_ALL("116;Avertissement~Le classement PVM quotidien vient d'être réinitialisé !"); 

		for(Personnage all : World.getOnlinePersos())
		{ 
			all.set_statscombats("24hPVM", 0); 
		} 

		SQLManager.RESET_24H_PVM();
	} 
}

 

Ça se complique à peine. Sur cette fonction, on vérifie l'heure qu'il est via Calendar.getInstance().get(Calendar.HOUR_OF_DAY). Si l'heure est comprise entre minuit et 1h, on remet à zéro le classement en avertissant le serveur pour la même occasion : Sachez donc que le classement peut se mettre à zéro entre minuit et 1h, tout dépend de la minute du moment où vous avez lancé le serveur. Je donne un exemple : Je lance le serveur à 14h45, la remise à zéro se fera donc à 0h45.

 

Après vérification de l'heure, on retrouve for(Personnage all : World.getOnlinePersos()) juste avant all.set_statscombats("24hPVM", 0); et juste avant SQLManager.RESET_24H_PVM();.

 

Petite explication nécessaire :

Petite explication nécessaire :

Lors de la remise à zéro via une requête SQL (ici RESET_24H_PVM(), fonction qu'on créera plus tard mais qui servira à remettre à zéro le classement), l'intégralité des joueurs aura l'expérience remise à zéro sauf les joueurs connectés. C'est pour cette raison que l'on utilise for(Personnage all : World.getOnlinePersos()). On sélectionne les joueurs connectés, et on remet à zéro leur points d'expérience gagnés en 24H via all.set_statscombats("24hPVM", 0); (fonction que nous créerons plus tard également)

 

On a déjà fini cette magnifique page qui contient normalement des erreurs, et c'est normal ! Bon, c'est bien beau tout ça mais il faut quand même définir le temps entre deux vérifications et bien évidemment lancer le timer du classement au démarrage de l'émulateur !

 

Rendez-vous dans Ancestra.java. Une fois dedans, cherchez (via ctrl+F) :

public static boolean CONFIG_DEBUG = false;

 

A la suite de ceci, sautez une ligne et mettez :

/** Classements **/ 
public static Classements ladders; 
public static int CONFIG_RAPPEL_LADDER = 3600000;

 

Il est évident qu'on aurait pu mettre directement la valeur de CONFIG_RAPPEL_LADDER dans Classements.java, mais... Voilà. On passe à la suite ? :)

 

On descend un peu plus en bas vers la création du GameServer (en dessous de la fin de la création du monde, toujours dans ce même fichier). Ce qui revient à chercher (toujours via Ctrl+F) :

gameServer = new GameServer(Ip);

 

Une fois arrivé, vous avez (ou pas, ça dépend de la révision) :

System.out.print("Lancement du traîtement des classements"); 
ladders = new Classements(); 
System.out.println(" : Traîtements lancés"); 

 

Bien évidemment, vous pouvez mettre les messages de System.out.print au singulier étant donné que dans ce tutoriel, nous avons créé qu'un système de classement automatique (pour ma part, j'en ai plusieurs mais passons).

 

Ça en est déjà fini pour Ancestra.java ! Rendez-vous dans SQLManager.java, c'est ici que la partie la plus longue va se passer (soyez courageux n.n). La sauvegarde des expériences gagnés en 24H devra se faire sur une autre table comme précisé en début de tutoriel (table que l'on créera plus tard), de ce fait nous alors créer une sauvegarde et un chargement spécialement dédié à cette table (croyez-moi, cette table devient vraiment utile si on s'en sert pour avoir diverses statistiques). On commence donc par créer la sauvegarde de la table (qui aura pour but de créer la ligne consacrée au personnage si elle n'existe pas, et de sauvegarder les statistiques de combats (ici l'expérience gagnée en 24H).

 

N'oubliez pas que l'émulateur utilisé est Ancestra Remake REV54. Si vous utilisez une version inférieure de cet émulateur, ce sera à vous d'y adapter cette modification.

 

Recherchez via Ctrl+F :

public static void UPDATE_LASTCONNECTION_INFO

 

Juste au dessus de cette fonction, nous allons en créer une nouvelle : celle qui consistera à sauvegarder la table 'stats_combats' :

public static void SAVE_STATSFORWEB(Personnage perso) { }

 

Bien évidemment, nous allons pas laisser le code comme ça. Dedans, nous devrons tout d'abord commencer par vérifier si le personnage a déjà été sauvegardé dans la table stats_combats.

try 
{ 
	ResultSet RS = executeQuery("SELECT * FROM stats_combats WHERE player_name='"+ perso.get_name()+"';",Ancestra.BDD_NOM); 

	if(!RS.first()) 
	{ 
		closeResultSet(RS);
	

 

Ici, on vérifie si la ligne existe à partir du nom du personnage recherché. Si elle n'existe pas (if(!RS.first())), on supprime la ligne qui a l'ID du personnage (au moins on est sûr de ne pas provoquer de conflits, et puis même si ça ne delete rien, ça ne laisse aucun message d'erreur).

		String baseQueryDelete = "DELETE FROM `stats_combats` WHERE `id` = ?"; 

		try 
		{ 
			PreparedStatement p = newTransact(baseQueryDelete, gameCon); 
			p.setInt(1, perso.get_GUID()); 

			p.execute(); 

			closePreparedStatement(p); 
		} 
		catch (SQLException e) 
		{ 
			GameServer.addToLog("Game: SQL ERROR: " + e.getMessage()); GameServer.addToLog("Game: Query: " + baseQueryDelete); 
		}

 

Après cette suppression, on passe donc comme prévu à l'insertion du personnage dans la table avec bien évidemment l'expérience et le record à zéro, rien de plus basique :

		String baseQueryInsert = "INSERT INTO `stats_combats`" + " VALUES (?,?,?,?);"; 

		try 
		{ 
			PreparedStatement p = newTransact(baseQueryInsert, gameCon); 
			p.setInt(1, (perso.get_GUID())); 
			p.setString(2, (perso.get_name())); 
			p.setLong(3, (0)); 
			p.setLong(4, (0)); 

			p.execute(); closePreparedStatement(p); 
		}
		catch(SQLException e) 
		{ 
			GameServer.addToLog("SQL ERROR :INSERT STATS_FORWEB: "+e.getMessage()); 
			e.printStackTrace(); 
		} 
	} 
}
catch(SQLException e) 
{ 
	GameServer.addToLog("SQL ERROR :INSERT STATS_FORWEB: "+e.getMessage()); 
	e.printStackTrace(); 
}

 

Mais ceci n'était que la première partie de la sauvegarde, puisque nous venons donc de sortir de la condition qui servait à savoir si la ligne existait ou pas (if(!RS.first())). Dans l'autre cas (si la ligne existe déjà), il suffit de l'update.

String baseQuery = "UPDATE `stats_combats` SET "+ "`24hPVM` = ?," + "`Record_24hPVM` = ?" + " WHERE `stats_combats`.`player_name` = ? LIMIT 1 ;";

PreparedStatement p = null; 

try 
{ 
	p = newTransact(baseQuery, gameCon); 
	p.setLong(1,perso.get_xp("24h")); 
	p.setLong(2,perso.get_recordxp("24h")); 
	p.setString(3,perso.get_name()); 
	
	p.executeUpdate(); 
}
catch(Exception e) 
{ 
	System.out.println("Game: SQL ERROR: "+e.getMessage()); 
	System.out.println("Requete: "+baseQuery); 
	System.out.println("Les StatsCombats du personnage n'ont pas ete sauvegardes"); 
}

 

Le système de sauvegarde des stats_combats est maintenant opérationnel, mais il faudrait avant tout les charger afin d'éviter de ré-avoir l'expérience gagnée en 24h à zéro à chaque redémarrage du serveur. On créer donc une nouvelle fonction pour charger la table 'stats_combats' :

public static void LOAD_STATSCOMBATS(Personnage perso) { }

 

Rien de compliqué jusqu'ici, on y ajoute donc le contenu :

try 
{ 
	ResultSet RS = SQLManager.executeQuery("SELECT * FROM stats_combats WHERE player_name = '"+perso.get_name()+"';", Ancestra.BDD_NOM); 

	while(RS.next())
	{ 
		RS.getInt("ID"); 
		RS.getString("player_name"); 
		perso.set_statscombats("24hPVM",RS.getLong("24hPVM")); 
		perso.set_statscombats("Record24hPVM",RS.getLong("Record_24hPVM")); 
	} 

	closeResultSet(RS); 
}
catch(SQLException e) 
{ 
	GameServer.addToLog("SQL ERROR: "+e.getMessage()); 
	e.printStackTrace(); 

	Ancestra.closeServers(); 
}

 

Récapitulatif :

Récapitulatif

Vous voilà donc avec pour le moment :

- Un timer qui remet le classement chaque jour de minuit à une heure et qui se relance à chaque démarrage du serveur.

- Un système qui sauvegarde et charge l'expérience gagnée en 24H ainsi que le record.

 

Il reste à faire :

- L'application du gain d'expérience en 24H et du record

- La mise en place de la sauvegarde, du chargement, et du gain d'expérience en 24H lors de la fin des combats, traques, ou autres.

- La création de la table 'stats_combats' - La création de la page PHP qui consistera à afficher le classement avec le record du bonhomme qui pète le plus de mobs.

 

Vous avez donc maintenant fini les deux systèmes qui consistent à sauvegarder et charger les stats_combats des joueurs, il reste néanmoins à appliquer ceci puisque la fonction ne va pas se faire "toute seule".

 

Rendez-vous donc dans

public static boolean ADD_PERSO_IN_BDD

 

Ceci devrait se situer pas très loin de là où vous êtes actuellement mais en cas de doutes, utilisez Ctrl+F. Arrivé à cette fonction qui comme son nom l'indique, sert à créer un personnage, nous allons en profiter pour y créer la première ligne de stats_combats du personnage. Dans cette fonction, cherchez "return true;", et juste au dessus, il suffit de placer

SAVE_STATSFORWEB(perso);

 

Et pouf, la ligne sera créée automatiquement étant donné que comme vu précédemment, cette sauvegarde créer la ligne lorsqu'elle n'existe pas. Évidemment, ces statistiques ne vont pas se sauvegarder uniquement à la création du personnage, il faut également que les statistiques soient sauvegardées à chaque sauvegarde du personnage. Pour que ceci soit fait, cherchez :

public static void SAVE_PERSONNAGE

 

Parcourez un peu cette fonction jusqu'à ce que vous tombiez sur la ligne :

GameServer.addToLog("Personnage "+_perso.get_name()+" sauvegarde");

 

Juste au dessus de cette ligne, placez :

SAVE_STATSFORWEB(_perso);

 

C'est bon, la sauvegarde et la création des stats_combats est désormais mise en place !

 

On en a fini avec SQLManager.java !

 

Sans perdre de temps, sachez que le chargement de cette table est peut être créé, mais il n'est pas mis en place. Le principe est simple : A chaque fois qu'un personnage sera chargé, son expérience gagnée en 24h (ainsi que son record) le seront également.

 

Dirigez-vous vers le fichier Personnage.java et cherchez (via Ctrl+F) :

this._title = title;

 

La fonction où vous êtes sert à définir les caractéristiques des joueurs (titre, PDVs, stats, métiers, etc..). Juste au dessus, insérez :

SQLManager.LOAD_STATSCOMBATS(this);

 

Maintenant, une question devrait vous taper fort sur la tête : o.O

 

Comment peut-on sauvegarder/créer/charger les 'stats_combats' alors qu'ils ne sont même pas définies par des variables ?

 

Eh bien... Nous allons le faire. Ne sortez pas de Personnage.java et cherchez (via Ctrl+F) :

private Map _storeItems

 

Et juste en dessous, mettez :

//Classements 
private long xp24h; 
private long record_xp24h;

 

Ce qui va donc servir à pouvoir accumuler l'expérience gagnée en 24H au fur et à mesure des combats et ainsi mettre à jour le record. Lors du chargement des stats_combats, les valeurs sont remises telles qu'elles étaient à la dernière sauvegarde, avant ce chargement, elles ont une valeur nulle. Cherchez (via Ctrl+F) :

public void startActionOnCell

 

Et au dessus, nous allons créer le petite fonction servant à charger les anciennes données sauvegardées afin que l'expérience gagnée en 24H ne se remette pas à zéro à chaque déconnexion.

public void set_statscombats(String type, long value) 
{ 
	if (type == "24hPVM") 
		xp24h = value; 
	else if (type == "Record24hPVM") 
		record_xp24h = value; 
}

 

Après avoir fait ceci, nous allons mettre en place une fonction qui sert bien évidemment à accumuler l'expérience gagnée au fur et à mesure des combats sans écraser l'ancienne sauvegarde des anciens combats de la même journée. Cette même fonction calculera si un record d'expérience gagné en 24H (personnel) a été effectué ou pas.

public void set_xp_ladders(long xp) 
{ 
	xp24h += xp; 
  
	if (xp24h > record_xp24h) 
		record_xp24h = xp24h; 
}

 

Lors de la sauvegarde de ces données, il faut que l'émulateur puisse récupérer la valeur de l'expérience gagnée en 24H ainsi que son record. Deux petites fonctions permettent de faire ceci sans aucun problème :

public long get_xp(String type)
{ 
	if (type == "24h")
		return xp24h; 
	else 
		return 0; 
} 

public long get_recordxp(String type)
{ 
	if (type == "24h")
		return record_xp24h; 
	else 
		return 0;
}

 

Cette façon de procéder avec String type peut paraître très bizarre surtout dans ce cas là mais sachez que si vous avez plusieurs systèmes de classement (c'est mon cas), il est nettement plus pratique de faire par exemple :

if (type == "24h")
	return xp24h; 
else if (type == "1s")
	return xp1s; 
else if (type == "1m")
	return xp1m; 
else 
	return 0;

 

Mais il n'est pas cas de ça sur ce tutoriel mais simplement du classement quotidien (sinon j'en aurai pour beaucoup trop de temps de rédaction ! Et puis cela ferrait un tutoriel trop gros). Passons donc à la suite ! On sait bien évidemment que le fichier Fight.java est un fichier plutôt spacieux et qui possède beaucoup de lignes. Mais une modification dessus est nécessaire (Bawi, sinon comment qu'on fait pour que l'expérience soit enregistrée après chaque combat !) Allez donc dans Fight.java et cherchez :

public String GetGE(int win)

 

Dans cette fonction qui est également très grande, cherchez :

if(winKamas != 0 && i.getPersonnage() != null)

 

Juste au dessus, dans la condition if(winxp != 0 && i.getPersonnage() != null){ il suffit d'ajouter une autre ligne :

i.getPersonnage().set_xp_ladders(winxp); //Classement

 

Pour ceux qui ont l'option du Kolizeum par Orime :

Pour ceux qui ont l'option du Kolizeum par Orime

Il est vrai qu'Orime a partagé une version du Kolizeum, certes "failleuse" et incomplète, mais c'est un début et je pense que de nombreux développeurs se sont penchés sur ce sujet pour le corriger et l'améliorer (si je l'ai fait, y'a aucune raison que personne d'autre ne le fasse). Pour ceux qui sont dans ce cas donc, cherchez F.getPersonnage().addXp(F.getPersonnage().getArena().getXpReward(F.getPersonnage()));, puis ajoutez les lignes en dessous : F.getPersonnage().set_xp_ladders(F.getPersonnage().getArena().getKamasReward(F.getPersonnage())); SQLManager.SAVE_STATSFORWEB(F.getPersonnage());

 

Pour ceux qui ont l'option des traques :

Pour ceux qui ont l'option des traques

Certains utilisent les traques par défaut sur Ancestra Remake (système que je déconseille), d'autres personnes l'ont corrigé un minimum. Pour que l'expérience soit donc également prise en compte sur les traques, rendez-vous dans Action.java, puis dans case 52:. Il s'agit de l'action qui sert à récompenser une traque. En dessous de perso.addXp(xp); Ajoutez tout simplement perso.set_xp_ladders(xp);

 

 

La partie en JAVA est désormais terminée ! 

 

 

Modification en SQL :

 

Étant donné que ça fait de nombreuses heures que je rédige ce tutoriel et que je commence à fatiguer (vu l'heure...), je vais vous mettre directement le code qui va créer la table.

 

Petite description : La table contient plusieurs colonnes :

1- ID du personnage

2- Nom du personnage

3- Expérience gagnée en 24H

4- Record d'expérience gagnée en 24H

 

Sachez que cette table doit également être dans la même database que la table 'personnages' : Soit dans le game (ancestra_game par défaut.

SET FOREIGN_KEY_CHECKS=0;

-- ---------------------------- 
-- Table structure for `stats_combats` 
-- ---------------------------- 
DROP TABLE IF EXISTS `stats_combats`; 
CREATE TABLE `stats_combats` ( 
	`ID` int(100) NOT NULL AUTO_INCREMENT, 
	`player_name` text NOT NULL, 
	`24hPVM` bigint(255) NOT NULL DEFAULT '0', 
	`Record_24hPVM` bigint(255) NOT NULL DEFAULT '0', 
	PRIMARY KEY (`ID`) 
) ENGINE=InnoDB AUTO_INCREMENT=15590 DEFAULT CHARSET=latin1;

 

Après avoir créé la table (sous PHPMyAdmin -> rafraîchissez la page, sous Navicat -> Clique droit, rafraîchir), nous allons directement passer à la création du fichier PHP. 

 

 

Modification en PHP :

 

Rien de plus simple, il vous suffit de créer un fichier PHP et de le nommer ladderPVM24h.php. Conseil : Torturez 'Bloc-Note' et téléchargez 'NotePad++'. Bien évidemment les fichiers CSS varient en fonction des CMS donc vous devrez procéder à une manière pour adapter ce tableau chez vous (ne m’appelez pas je suis nul en .css). Nous allons commencer ce fichier PHP par une simple prévention comme quoi les personnages n'ayant pas combattus sont retirés de ce classement (histoire de ne pas surcharger) :

echo "<center><h1><center>Classement PVM : Reset toutes les 24heures.</center></h1><br />";
echo "Attention : Les personnages ayant 0 point d'expérience sont automatiquement retirés de ce classement.<br /><br />";

 

On continue en créant le mini-tableau d'une ligne qui présentera la personne qui a le plus grand record d'expérience gagné en 24H parmi les joueurs :

echo "Record d'XP gagnés en 24H :";
echo "<table>";
echo "<tr><th>Nom</th><th>Experience</th></tr>";

 

On définit d'abord les colonnes, puis on recherche le bonhomme :

$ListePerso = mysql_query("SELECT * FROM stats_combats WHERE  `Record_24hPVM` > 0 ORDER BY `Record_24hPVM` DESC LIMIT 1"); 
$ListePersoEnd = mysql_fetch_array($ListePerso);

 

Puis on affiche :

echo "<tr><td><b>$ListePersoEnd['player_name']</b></td><td>$ListePersoEnd['Record_24hPVM'];</td></tr>";
echo "</table><br /><br />";

 

Une fois que le bonhomme est affiché, on fait la même chose en fixant une limitation plus élevée, et en cherchant l'expérience gagnée en 24H tout simplement :

echo "<table>";
echo "<tr><th>Position</th><th>Nom</th><th>Experience</th></tr>";

$i = 1;
$ListePerso = mysql_query("SELECT * FROM stats_combats WHERE  `24hPVM` > 0  ORDER BY `24hPVM` DESC LIMIT 100");

 

Les 100 premiers personnages seront affichés. On affiche les joueurs :

while ($ListePersoEnd = mysql_fetch_array($ListePerso))
{ 
	echo"<tr><td>$i</td><td><b>$ListePersoEnd['player_name'];</b></td><td>$ListePersoEnd['24hPVM'];</td></tr>
	$i++; 
}

echo "</table>"

 

Voilou, tutoriel terminé !

 

 

B| On peut dire que c'était assez cool pour environ 530 lignes de tutoriel, même si ce n'est pas sûr que vous ayez suivi.
Il y a des survivants ? :angel:

 

Edited by Nicosti
Réparation du formattage
  • Like 2

Share this post


Link to post
Share on other sites

Outch, ça c'est du tuto !

J'avoue ne pas avoir eu le courage de tout lire, mais un grand merci quand même pour ton active participation au sein de la section privée qui est malheureusement pas super active !

Share this post


Link to post
Share on other sites

Pour information LIMIT 0, x peut être utilisé LIMIT x. Plus rapide, plus simple et plus beau ;)

Share this post


Link to post
Share on other sites