home *** CD-ROM | disk | FTP | other *** search
/ Fraggin / Fraggin.iso / utils / wad1to2 / makemap / makemap.c < prev    next >
C/C++ Source or Header  |  1994-11-03  |  11KB  |  430 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <structs.h>
  5.  
  6. #define MAPFILE_MAX_SIZE    2000
  7.  
  8. char *wad1text[MAPFILE_MAX_SIZE];
  9. char *wad2text[MAPFILE_MAX_SIZE];
  10.  
  11.  
  12. void *GetMemory( size_t size)
  13. {
  14.     void *ret = malloc( size);
  15.     if (!ret)
  16.     {
  17.         printf( "out of memory (cannot allocate %u bytes)", size);
  18.         exit(0);
  19.     }
  20.  
  21.    return ret;
  22. }
  23.  
  24. struct directory* FindDirEntry (FILE *wad, struct wad_header *wad_hdr, char *name)
  25. {
  26.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  27.     char namestr[]= "\0\0\0\0\0\0\0\0\0";
  28.     int n;
  29.  
  30.  
  31.     fseek (wad, wad_hdr->dir_start, SEEK_SET);
  32.     for (n = 0; n < wad_hdr->num_entries; n++)
  33.     {
  34.         fread (dir_entry, sizeof( struct directory), 1, wad);
  35.         strncpy (namestr, dir_entry->name, 8);
  36.         if (strcmp (namestr, name) == 0)
  37.             return (dir_entry);
  38.     }
  39.  
  40.     return (NULL);
  41. }
  42.  
  43.  
  44. void GetFloorTexts (FILE *wad, struct wad_header *wad_hdr, char *textures[])
  45. {
  46.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  47.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  48.     char *p;
  49.     long int i;
  50.  
  51.  
  52.     dir_entry = FindDirEntry(wad, wad_hdr, "F_START");
  53.  
  54.     for( i = 0; i < wad_hdr->num_entries; i++)
  55.     {
  56.         fread (dir_entry, sizeof( struct directory), 1, wad);
  57.         strncpy (buf, dir_entry->name, 8);
  58.         if (strcmp (buf, "F_END") == 0)
  59.             break;
  60.  
  61.         if (strcmp (buf, "F1_START") == 0 || strcmp (buf, "F1_END") == 0 ||
  62.             strcmp (buf, "F2_START") == 0 || strcmp (buf, "F2_END") == 0 ||
  63.             strcmp (buf, "F3_START") == 0 || strcmp (buf, "F3_END") == 0)
  64.             continue;
  65.  
  66.         p = GetMemory (strlen (buf) + 1);
  67.         strcpy (p, buf);
  68.         *textures++ = p;
  69.     }
  70.  
  71.     p = GetMemory (3);
  72.     strcpy (p, "");
  73.     *textures = p;
  74.     return;
  75. }
  76.  
  77.  
  78. void GetWallPatches (FILE *wad, struct wad_header *wad_hdr, char *textures[])
  79. {
  80.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  81.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  82.     char *p;
  83.     long int i;
  84.  
  85.  
  86.     dir_entry = FindDirEntry(wad, wad_hdr, "P_START");
  87.  
  88.     for( i = 0; i < wad_hdr->num_entries; i++)
  89.     {
  90.         fread (dir_entry, sizeof( struct directory), 1, wad);
  91.         strncpy (buf, dir_entry->name, 8);
  92.         if (strcmp (buf, "P_END") == 0)
  93.             break;
  94.  
  95.         if (strcmp (buf, "P1_START") == 0 || strcmp (buf, "P1_END") == 0 ||
  96.             strcmp (buf, "P2_START") == 0 || strcmp (buf, "P2_END") == 0 ||
  97.             strcmp (buf, "P3_START") == 0 || strcmp (buf, "P3_END") == 0)
  98.             continue;
  99.  
  100.         p = GetMemory (strlen (buf) + 1);
  101.         strcpy (p, buf);
  102.         *textures++ = p;
  103.     }
  104.  
  105.     p = GetMemory (3);
  106.     strcpy (p, "");
  107.     *textures = p;
  108.     return;
  109. }
  110.  
  111.  
  112. void GetSounds (FILE *wad, struct wad_header *wad_hdr, char *textures[])
  113. {
  114.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  115.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  116.     char *p;
  117.     long int i;
  118.  
  119.  
  120.     fseek (wad, wad_hdr->dir_start, SEEK_SET);
  121.  
  122.     for( i = 0; i < wad_hdr->num_entries; i++)
  123.     {
  124.         fread (dir_entry, sizeof( struct directory), 1, wad);
  125.         strncpy (buf, dir_entry->name, 8);
  126.         if (buf[0] == 'D' && (buf[1] == 'P' || buf[1] == 'S'))
  127.         {
  128.             p = GetMemory (strlen (buf) + 1);
  129.             strcpy (p, buf);
  130.             *textures++ = p;
  131.         }
  132.     }
  133.  
  134.     p = GetMemory (3);
  135.     strcpy (p, "");
  136.     *textures = p;
  137.     return;
  138. }
  139.  
  140.  
  141. void GetSprites (FILE *wad, struct wad_header *wad_hdr, char *textures[])
  142. {
  143.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  144.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  145.     char *p;
  146.     long int i;
  147.  
  148.  
  149.     dir_entry = FindDirEntry(wad, wad_hdr, "S_START");
  150.  
  151.     for( i = 0; i < wad_hdr->num_entries; i++)
  152.     {
  153.         fread (dir_entry, sizeof( struct directory), 1, wad);
  154.         strncpy (buf, dir_entry->name, 8);
  155.         if (strcmp (buf, "S_END") == 0)
  156.             break;
  157.  
  158.         p = GetMemory (strlen (buf) + 1);
  159.         strcpy (p, buf);
  160.         *textures++ = p;
  161.     }
  162.  
  163.     p = GetMemory (3);
  164.     strcpy (p, "");
  165.     *textures = p;
  166.     return;
  167. }
  168.  
  169.  
  170. void GetTextures (FILE *wad, struct directory *dir_entry, char *textures[])
  171. {
  172.     int i, j, alph;
  173.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  174.     char *p;
  175.  
  176.     for ( ; strlen(*textures) != 0; textures++)
  177.         ;
  178.  
  179.     fseek (wad, dir_entry->start, SEEK_SET);
  180.  
  181.     for (i = 0; i < 8; i++)
  182.         buf[i] = getc(wad);
  183.  
  184.     for ( ; i < dir_entry->length; i++)
  185.     {
  186.         for (j = 0; j < 7; j++)
  187.             buf[j] = buf[j+1];
  188.         buf[7] = getc(wad);
  189.  
  190.         if (isgraph (buf[7]) || buf[7] == '\0')
  191.             alph++;
  192.         else
  193.             alph = 0;
  194.  
  195.         if (alph >= 8 && isgraph (buf[0]) && isgraph (buf[1])
  196.              && isgraph (buf[2]) && isgraph (buf[3]))
  197.         {
  198.             alph=0;
  199.             p = GetMemory (strlen (buf) + 1);
  200.             strcpy (p, buf);
  201.             *textures++ = p;
  202.         }
  203.     }
  204.     p = GetMemory (3);
  205.     strcpy (p, "");
  206.     *textures = p;
  207. }
  208.  
  209.  
  210. void WriteMappings (FILE *mapfile, char *textlist1[], char *textlist2[], char *Heading)
  211. {
  212.     int i, j, n;
  213.  
  214.     fprintf (mapfile, "%s\r\n", Heading);
  215.  
  216.     for (i = 0; i < MAPFILE_MAX_SIZE; i++)
  217.     {
  218.         if (strlen(textlist1[i]) == 0)
  219.             break;
  220.  
  221.         for (j = 0; strlen(textlist2[j]) != 0; j++)
  222.         {
  223.             if (strcmp(textlist1[i], textlist2[j]) == 0)
  224.                 break;
  225.         }
  226.  
  227.         if (strlen(textlist2[j]) != 0)
  228.             continue;
  229.  
  230.         for (n = 7; n > 0; n--)
  231.         {
  232.             for (j = 0; strlen(textlist2[j]) != 0; j++)
  233.             {
  234.                 if (strncmp(textlist1[i], textlist2[j], n) == 0)
  235.                 {
  236.                     fprintf (mapfile, "%-8s %-8s\r\n", textlist1[i], textlist2[j]);
  237.                     break;
  238.                 }
  239.             }
  240.             if (strlen(textlist2[j]) != 0)
  241.                 break;
  242.         }
  243.     }
  244.     fprintf (mapfile, "\r\n");
  245. }
  246.  
  247.  
  248. void ListAll (char *filename, char *textlist1[], char *textlist2[])
  249. {
  250.     FILE *listfile;
  251.     int i;
  252.     int filedone = 0;
  253.  
  254.     if ((listfile = fopen(filename, "wb+")) == NULL)
  255.     {
  256.         printf ("Error:  Cannot create %s\r\n", filename);
  257.         return;
  258.     }
  259.  
  260.     for (i = 0; i < MAPFILE_MAX_SIZE; i++)
  261.     {
  262.         if (!filedone)
  263.         {
  264.             if (strlen(textlist1[i]) == 0)
  265.                 filedone = 1;
  266.             else if (strlen(textlist2[i]) == 0)
  267.                 filedone = 2;
  268.             else
  269.                 fprintf (listfile, "%-8s %-8s\r\n", textlist1[i], textlist2[i]);
  270.         }
  271.         if (filedone == 1)
  272.         {
  273.             if (strlen(textlist2[i]) == 0)
  274.                 break;
  275.             fprintf (listfile, "         %-8s\r\n", textlist2[i]);
  276.         }
  277.         if (filedone == 2)
  278.         {
  279.             if (strlen(textlist1[i]) == 0)
  280.                 break;
  281.             fprintf (listfile, "%-8s\r\n", textlist1[i]);
  282.         }
  283.     }
  284.     fclose (listfile);
  285. }
  286.  
  287.  
  288.  
  289. main (int argc, char *argv[])
  290. {
  291.     FILE *wad1, *wad2, *mapfile;
  292.     struct wad_header *wad1_hdr = GetMemory( sizeof( struct wad_header));
  293.     struct wad_header *wad2_hdr = GetMemory( sizeof( struct wad_header));
  294.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  295.     int i;
  296.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  297.  
  298.  
  299.     printf ("\r\n*** Mapfile maker for WAD1TO2 pwad converter v1.0 (c) 1994 Tracy F. Thonn ***\r\n\n");
  300.  
  301.     if ((wad1 = fopen("\\doom\\doom.wad", "rb")) == NULL)
  302.     {
  303.         printf ("Error:  Cannot open \\doom\\doom.wad\r\n");
  304.         return (1);
  305.     }
  306.  
  307.     if ((wad2 = fopen("\\doom2\\doom2.wad", "rb")) == NULL)
  308.     {
  309.         printf ("Error:  Cannot open \\doom2\\doom2.wad\r\n");
  310.         fclose (wad1);
  311.         return (1);
  312.     }
  313.  
  314.     if ((mapfile = fopen("makemap.map", "wb+")) == NULL)
  315.     {
  316.         printf ("Error:  Cannot create texture.map\r\n");
  317.         fclose (wad1);
  318.         fclose (wad2);
  319.         return (1);
  320.     }
  321.  
  322.     fprintf (mapfile, "[Wad1to2 Mapfile]\r\n");
  323.     fprintf (mapfile, "[by TFT]\r\n\r\n");
  324.  
  325.     printf ("Mapping levels...\r\n");
  326.     fprintf (mapfile, "[level1  level2]\r\n");
  327.     for (i = 0; i < 32; i++)
  328.     {
  329.         fprintf (mapfile, "E%1dM%1d     MAP%02d\r\n", (i / 9) + 1, (i % 9) + 1, i + 1);
  330.     }
  331.     fprintf (mapfile, "\r\n");
  332.  
  333.  
  334.     fread(wad1_hdr, sizeof( struct wad_header), 1, wad1);
  335.     fread(wad2_hdr, sizeof( struct wad_header), 1, wad2);
  336.  
  337.  
  338.     printf ("Mapping wall textures...\r\n");
  339.     dir_entry = FindDirEntry(wad1, wad1_hdr, "TEXTURE1");
  340.     printf ("        texture1: %lu chars at %lu\r\n", dir_entry->length, dir_entry->start);
  341.     wad1text[0] = NULL;
  342.     GetTextures (wad1, dir_entry, wad1text);
  343.  
  344.     dir_entry = FindDirEntry(wad1, wad1_hdr, "TEXTURE2");
  345.     printf ("        texture2: %lu chars at %lu\r\n", dir_entry->length, dir_entry->start);
  346.     GetTextures (wad1, dir_entry, wad1text);
  347.  
  348.  
  349.     dir_entry = FindDirEntry(wad2, wad2_hdr, "TEXTURE1");
  350.     printf ("        texture1: %lu chars at %lu\r\n", dir_entry->length, dir_entry->start);
  351.     GetTextures (wad2, dir_entry, wad2text);
  352.  
  353.  
  354.     ListAll ("texture.all", wad1text, wad2text);
  355.     WriteMappings (mapfile, wad1text, wad2text, "[textur1 textur2]");
  356.  
  357.  
  358.     printf ("Mapping wall patches...\r\n");
  359.     GetWallPatches (wad1, wad1_hdr, wad1text);
  360.     GetWallPatches (wad2, wad2_hdr, wad2text);
  361.     ListAll ("wpatch.all", wad1text, wad2text);
  362.     WriteMappings (mapfile, wad1text, wad2text, "[patch1  patch2]");
  363.  
  364.  
  365.     printf ("Mapping floor textures...\r\n");
  366.     GetFloorTexts (wad1, wad1_hdr, wad1text);
  367.     GetFloorTexts (wad2, wad2_hdr, wad2text);
  368.     ListAll ("floortxt.all", wad1text, wad2text);
  369.     WriteMappings (mapfile, wad1text, wad2text, "[floor1  floor2]");
  370.  
  371.  
  372. /***
  373.     printf ("Mapping sprites...\r\n");
  374.     GetSprites (wad1, wad1_hdr, wad1text);
  375.     GetSprites (wad2, wad2_hdr, wad2text);
  376.     ListAll ("sprites.all", wad1text, wad2text);
  377.     WriteMappings (mapfile, wad1text, wad2text, "[sprite1 sprite2]");
  378. ***/
  379.  
  380.     printf ("Mapping sounds...\r\n");
  381.     GetSounds (wad1, wad1_hdr, wad1text);
  382.     GetSounds (wad2, wad2_hdr, wad2text);
  383.     ListAll ("sounds.all", wad1text, wad2text);
  384.     WriteMappings (mapfile, wad1text, wad2text, "[sound1  sound2]");
  385.  
  386.  
  387.     printf ("Mapping music entries...\r\n");
  388.     fprintf (mapfile, "[music1  music2]\r\n");
  389.     dir_entry = FindDirEntry(wad2, wad2_hdr, "D_RUNNIN");
  390.     strncpy (buf, dir_entry->name, 8);
  391.     fprintf (mapfile, "D_E1M1   %-8s\r\n", buf);
  392.     for (i = 1; i < 32; i++)
  393.     {
  394.         fread (dir_entry, sizeof( struct directory), 1, wad2);
  395.         strncpy (buf, dir_entry->name, 8);
  396.         fprintf (mapfile, "D_E%1dM%1d   %-8s\r\n", (i / 9) + 1, (i % 9) + 1, buf);
  397.     }
  398.     fread (dir_entry, sizeof( struct directory), 1, wad2);
  399.     strncpy (buf, dir_entry->name, 8);
  400.     fprintf (mapfile, "D_VICTOR %-8s\r\n", buf);
  401.     fread (dir_entry, sizeof( struct directory), 1, wad2);
  402.     strncpy (buf, dir_entry->name, 8);
  403.     fprintf (mapfile, "D_INTRO  %-8s\r\n", buf);
  404.     fread (dir_entry, sizeof( struct directory), 1, wad2);
  405.     strncpy (buf, dir_entry->name, 8);
  406.     fprintf (mapfile, "D_INTER  %-8s\r\n", buf);
  407.     fprintf (mapfile, "\r\n");
  408.  
  409.     printf ("Mapping old demos...\r\n");
  410.     fprintf (mapfile, "[demo1   void2]\r\n");
  411.     fprintf (mapfile, "DEMO1    OLDDEMO1\r\n");
  412.     fprintf (mapfile, "DEMO2    OLDDEMO2\r\n");
  413.     fprintf (mapfile, "DEMO3    OLDDEMO3\r\n");
  414.     fprintf (mapfile, "\r\n");
  415.  
  416.  
  417.     fclose (wad1);
  418.     fclose (wad2);
  419.     fclose (mapfile);
  420.  
  421.     printf ("\r\nFiles created...\r\n");
  422.     printf ("    makemap.map  - starter mapfile for use with wad1to2.exe\r\n");
  423.     printf ("    texture.all  - list of all wall texture names for Doom1 and Doom2\r\n");
  424.     printf ("    wpatch.all   - list of all wall patch names for Doom1 and Doom2\r\n");
  425.     printf ("    floortxt.all - list of all floor and ceiling textures for Doom1 and Doom2\r\n");
  426.     printf ("    sounds.all   - list of all the sound names for Doom1 and Doom2\r\n");
  427.  
  428.     return (0);
  429. }
  430.