Fusion des nouveaux compteurs.

[tosh]

Bonjour, si ça intéresse quelqu'un, j'ai fais un petit programme qui permet de fusionner les compteurs des anciens monstres (Orc mâle, gobelin mâle, gobelin femelle, orc femelle, orc armée,) avec ceux des nouveaux monstres (Orque, gobelin, gobeline, orque armé, orque armée). Si j'en ai oublié, merci de me le signaler

(En gros, si vous avez dans vos compteurs : Orque : 50 et Orc mâle : 500, vous n'aurez plus que Orque : 550 dans vos compteurs)

Bon, en principe, ça fonctionne, mais on est jamais à l'abri des bugs, je vous conseil donc de sauvegarder votre ancien fichier de counters.

Le fonctionnement est tout bête : vous lancez le programme en ligne de commande, en spécifiant en premier argument le chemin de votre fichier de counters (c'est un fichier qui se nomme : counters_PSEUDO.dat), et en second argument le nom du fichier modifié (Vous aurez donc à la sortie, votre fichier non modifié de compteurs, et le fichier modifié, qu'il faudra renommer en counters_PSEUDO.dat et placer au même endroit que le précédent)

Un petit exemple sous Linux :

Code : Tout sélectionner

cd ~/.lec/main/

Code : Tout sélectionner

./conv counters_tosh.dat tmp.dat

Pour la sauvegarde

Code : Tout sélectionner

mv counters_tosh.dat ~/Documents/

Code : Tout sélectionner

mv tmp.dat counters_tosh.dat

Source + exécutable Linux : http://dl.free.fr/oXFuk7QYX
La source pour ceux qui ont la flemme de téléchager :

Code : Tout sélectionner

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define ERROR(str) {perror(str);exit(1);}
struct counter
{
   unsigned char counter_id;
   unsigned char name_len;
   unsigned int extra;
   unsigned int total;
   unsigned char name[64];
};
struct elem
{
   struct counter count;
   struct elem *suiv;
};

struct pile
{
   int nb_elem;
   struct elem *tete;
};

struct pile *init_pile (void);
void clear_pile (struct pile *Pile);
void push (struct pile *Pile, struct counter *count);
void pop (struct pile *Pile, struct counter *count);

struct pile *init_pile (void)
{
   struct pile *Pile = malloc (sizeof (struct pile));
   if (Pile == NULL)
      return NULL;
   Pile->tete = NULL;
   Pile->nb_elem = 0;
   return Pile;
}

void clear_pile (struct pile *Pile)
{
   struct counter tmp;
   while (Pile->tete != NULL)
   {
      pop (Pile, &tmp);
   }
   free (Pile);
   Pile = NULL;
}

//empile un élément dans la pile
void push (struct pile *Pile, struct counter *count)
{
   struct elem *new_elem = malloc (sizeof (struct elem));
   if (new_elem != NULL)
   {
      memcpy (&new_elem->count, count, sizeof (struct counter));
      new_elem->suiv = Pile->tete;
      Pile->tete = new_elem;
      Pile->nb_elem++;
   }
}

//dépile un élément et le stock dans la struct counter
void pop (struct pile *Pile, struct counter *count)
{
   struct elem *tmp;

   if (Pile->tete != NULL)
   {
      memcpy (count, &Pile->tete->count, sizeof (struct counter));
      tmp = Pile->tete;
      Pile->tete = Pile->tete->suiv;
      free (tmp);
      Pile->nb_elem--;
   }
}

void load_file (char *filename, struct pile *Pile)
{
   FILE *fd;
   struct counter tmp;
   if ((fd = fopen (filename, "rb")) == NULL)
      ERROR ("fopen()");
   while (fread (&tmp.counter_id, sizeof (tmp.counter_id), 1, fd) > 0)
   {
      fread (&tmp.name_len, sizeof (tmp.name_len), 1, fd);
      fread (tmp.name, tmp.name_len, 1, fd);
      tmp.name[tmp.name_len] = '\0';

      fread (&tmp.extra, sizeof (tmp.extra), 1, fd);
      fread (&tmp.total, sizeof (tmp.total), 1, fd);

      if (strlen (tmp.name) < 1 || strlen (tmp.name) > 100)
      {
         //doesn't seem to have a real name, so we don't want it
         continue;

      }
     push(Pile, &tmp);
   }
   fclose(fd);
}
void print_counters_pile(struct pile *Pile)
{
   struct counter tmp;
   while(Pile->nb_elem > 0)
   {
      pop(Pile, &tmp);
      printf("ID: %d\n", tmp.counter_id);
      printf("NAME_LEN: %d\n", tmp.name_len);
      printf("NAME: '%s'\n", tmp.name);
      printf("EXTRA: %d\n", tmp.extra);
      printf("TOTAL: %d\n", tmp.total);     
   }
}
void fwrite_counters(FILE *fd, struct counter *count)
{
   fwrite(&count->counter_id, sizeof(count->counter_id), 1, fd);
   fwrite(&count->name_len, sizeof(count->name_len), 1, fd);
   fwrite(count->name, count->name_len, 1, fd);
   fwrite(&count->extra, sizeof(count->extra), 1, fd);
   fwrite(&count->total, sizeof(count->total), 1, fd);
}
void init_struct_counter(struct counter *count, char *name, int id)
{
   memset(count, 0, sizeof(struct counter));
   strncpy(count->name, name, sizeof(count->name)-1);
   count->name_len = strlen(count->name);
   count->counter_id = id;
}
void save_new_counters(char *filename, struct pile *Pile)
{
   FILE *fd;
   struct counter tmp;
   //count[0] pour les tués, count[1] pour les décés
   struct counter gobelin[2];
   struct counter gobeline[2];
   struct counter orque[2];
   struct counter orque_arme[2];
   struct counter orque_armee[2];
   struct counter guerrier_fantome[2];
   struct counter ogre[2];
   
   //Initialisation des structures
   init_struct_counter(&gobelin[0], "Gobelin", 1);   
   init_struct_counter(&gobelin[1], "Gobelin", 2);
   
   init_struct_counter(&gobeline[0], "Gobeline", 1);   
   init_struct_counter(&gobeline[1], "Gobeline", 2);
   
   init_struct_counter(&orque[0], "Orque", 1);   
   init_struct_counter(&orque[1], "Orque", 2);
   
   init_struct_counter(&orque_arme[0], "Orque arm\xe9", 1);   
   init_struct_counter(&orque_arme[1], "Orque arm\xe9", 2);
   
   init_struct_counter(&orque_armee[0], "Orque arm\xe9\x65", 1);   
   init_struct_counter(&orque_armee[1], "Orque arme\xe9\x65", 2);      
   
   init_struct_counter(&guerrier_fantome[0], "Guerrier fant\xf4me", 1);   
   init_struct_counter(&guerrier_fantome[1], "Guerrier fant\xf4me", 2);
   
   init_struct_counter(&ogre[0], "Ogre", 1);
   init_struct_counter(&ogre[1], "Ogre", 2);
   
   //Ouverture du fichier
   if((fd = fopen(filename, "wb+")) == NULL)
     ERROR("fopen()"); 
   while(Pile->nb_elem > 0)
   {
      int i = tmp.counter_id;
      i = (i==1)? 0 : 1;
      
      //On dépile chaque élément, et on incrémente la structure adéquate si c'est un nom qui a changé
      pop(Pile, &tmp);
      if(strcmp(tmp.name, "Gobelin m\xE2le") == 0 || strcmp(tmp.name, "Gobelin") == 0)
      {
         gobelin[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Gobelin femelle") == 0 || strcmp(tmp.name, "Gobeline") == 0)
      {        
         gobeline[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Orc m\xE2le") == 0 || strcmp(tmp.name, "Orc femelle") == 0 || strcmp(tmp.name, "Orque") == 0)
      {
         orque[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Orc arm\xe9") == 0 || strcmp(tmp.name, "Orque arm\xe9") == 0)
      {
         orque_arme[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Orc arm\xe9\x65") == 0 || strcmp(tmp.name, "Orque arm\xe9\x65") == 0)
      {
         orque_armee[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Guerrier fant\xf4me") == 0 || strcmp(tmp.name, "Combattant fant\xf4me") == 0)
      {
         guerrier_fantome[i].total += tmp.total;
      }
      else if(strcmp(tmp.name, "Ogre") == 0 || strcmp(tmp.name, "Ogre m\xe2le") == 0)
      {
         ogre[i].total += tmp.total;
      }
      else
      {
        fwrite_counters(fd, &tmp);
      }  
   }
   
   //On écrit les structures qui ont changé
   //TUES
   if(gobelin[0].total > 0)
      fwrite_counters(fd, &gobelin[0]);  
            
   if(gobeline[0].total > 0)
      fwrite_counters(fd,&gobeline[0]);
      
   if(orque[0].total > 0)
      fwrite_counters(fd, &orque[0]);
      
   if(orque_arme[0].total > 0)
      fwrite_counters(fd, &orque_arme[0]);
      
   if(orque_armee[0].total > 0)
      fwrite_counters(fd, &orque_armee[0]);   
      
   if(guerrier_fantome[0].total > 0)
     fwrite_counters(fd, &guerrier_fantome[0]);
   
   if(ogre[0].total > 0)
      fwrite_counters(fd, &ogre[0]);
   
   //DECES 
   if(gobelin[1].total > 0)
      fwrite_counters(fd, &gobelin[1]);  
            
   if(gobeline[1].total > 0)
      fwrite_counters(fd,&gobeline[1]);
      
   if(orque[1].total > 0)
      fwrite_counters(fd, &orque[1]);
      
   if(orque_arme[1].total > 0)
      fwrite_counters(fd, &orque_arme[1]);
      
   if(orque_armee[1].total > 0)
      fwrite_counters(fd, &orque_armee[1]);  
       
   if(guerrier_fantome[1].total > 0)
     fwrite_counters(fd, &guerrier_fantome[1]); 
   
   if(ogre[1].total > 0)
     fwrite_counters(fd, &ogre[1]);
        
   fclose(fd);  
}
int main (int argc, char **argv)
{
   char *file_name_src = argv[1];
   char *file_name_dst = argv[2];
   struct pile *File_src;
   if (argc != 3)
   {
      printf ("Usage : ./conv <fichier_source> <fichier_dest>\n");
      return 0;
   }
   if ((File_src = init_pile ()) == NULL)
      ERROR ("init_pile()");
   load_file (file_name_src, File_src);
   save_new_counters(file_name_dst, File_src);
   printf("Modification du fichier %s appliquée sur %s réussie.\n", file_name_src, file_name_dst);
   return 0;
}

C'est pas du grand code, j'ai fais ça vite fait

Monstres gérés :
Gobelin mâle -> Gobelin
Gobelin femelle -> Gobeline
Orc mâle -> Orque
Orc femelle -> Orque
Orc armé -> Orque armé
Orc armée -> Orque armée
Combattant fantôme -> Guerrier fantôme
Ogre mâle -> Ogre

EDIT: source et archive mis à jour.
EDIT 2 : j'avais oublié les pauvres ogres.

[Razamut]

Je crois qu'il te manque le Combattant Fantome qui s'est transforme en Guerrier Fantome.

Et j'ai combattu des Soldats Squelettes qui sont répertoriés sur le site des gardiens comme etant le nouveau nom des Squelettes Armes mais je ne suis pas sur car ils m'avaient sembles plus difficiles que des squelettes armes. Il faudrait aller vérifier sur un spawn de squelette arme pour être sur genre Morcraven.

[tosh]

Merci Razamut!

Apparemment, les squelettes armés n'ont pas changé de noms. (Je suis allé voir à Mocraven)
J'édite la source et le lien pour rajouter le Guerrier fantôme.

[Etory]

Je crois qu'il te manque le Combattant Fantome qui s'est transforme en Guerrier Fantome.

Et j'ai combattu des Soldats Squelettes qui sont répertoriés sur le site des gardiens comme etant le nouveau nom des Squelettes Armes mais je ne suis pas sur car ils m'avaient sembles plus difficiles que des squelettes armes. Il faudrait aller vérifier sur un spawn de squelette arme pour être sur genre Morcraven.

Les soldats squelettes sont de nouveaux monstres sans rapport avec les squelettes armés.

[Mayhem]

Ah bah sinon ya aussi moyen de le faire online par ici :

http://gilde.gt.free.fr/tools/LE-counters-correct.php


Certaines des corrections apportées sont liées à d'anciennes modifications/erreurs (comme les démons d'jhi qui ont brièvement été mal orthographiés à leurs tout débuts).

Petit détail, je convertis volontairement les orcs mâles et femelles en 'Orque mâle' et 'Orque femelle', plutot que de fusionner les deux en 'Orque', le résultat étant moins précis :/