home *** CD-ROM | disk | FTP | other *** search
/ Fraggin / Fraggin.iso / utils / wad1to2 / wad1to2.c < prev    next >
C/C++ Source or Header  |  1994-11-03  |  9KB  |  385 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <io.h>
  5. #include <structs.h>
  6.  
  7. #define MAPFILE_MAX_SIZE    500
  8.  
  9. typedef struct {
  10.     char wad1[9];
  11.     char wad2[9];
  12. } MappingStruct;
  13.  
  14. MappingStruct ChgWord[MAPFILE_MAX_SIZE];
  15. MappingStruct ChgDir[MAPFILE_MAX_SIZE];
  16.  
  17.  
  18. void *GetMemory( size_t size)
  19. {
  20.     void *ret = malloc( size);
  21.     if (!ret)
  22.     {
  23.         printf( "\r\nout of memory (cannot allocate %u bytes)\r\n", size);
  24.         exit(0);
  25.     }
  26.  
  27.    return ret;
  28. }
  29.  
  30.  
  31. int LoadMapfile (char *filename)
  32. {
  33.     FILE *mapfile;
  34.     int i = 0;
  35.     int j = 0;
  36.     int DirType = 0;
  37.     char Text1[9], Text2[9];
  38.  
  39.     if ((mapfile = fopen(filename, "rt")) == NULL || feof(mapfile))
  40.     {
  41.         printf ("\r\nError:  Cannot open %s or empty file\r\n", filename);
  42.         return (1);
  43.     }
  44.  
  45.     printf ("loading map file:  %s\r\n", filename);
  46.     while (!feof(mapfile) && i < (MAPFILE_MAX_SIZE - 1) && j < (MAPFILE_MAX_SIZE - 1))
  47.     {
  48.         if (fscanf (mapfile, "%8s %8s", Text1, Text2) < 2)
  49.             break;
  50.     /*    printf ("%s --> %s\r\n", Text1, Text2); */
  51.  
  52.         if (Text1[0] == '[')
  53.         {
  54.             if ( (strcmp (Text1, "[textur1") == 0) ||
  55.                  (strcmp (Text1, "[floor1") == 0)  )
  56.             {
  57.                 DirType = 0;
  58.             }
  59.             else if ( (strcmp (Text1, "[level1") == 0) ||
  60.                   (strcmp (Text1, "[patch1") == 0) ||
  61.                   (strcmp (Text1, "[music1") == 0) ||
  62.                   (strcmp (Text1, "[sound1") == 0) ||
  63.                   (strcmp (Text1, "[demo1") == 0) )
  64.             {
  65.                 DirType = 1;
  66.             }
  67.         }
  68.         else if (DirType)
  69.         {
  70.             strcpy (ChgDir[j].wad1, Text1);
  71.             strcpy (ChgDir[j].wad2, Text2);
  72.             j++;
  73.         }
  74.         else
  75.         {
  76.             strcpy (ChgWord[i].wad1, Text1);
  77.             strcpy (ChgWord[i].wad2, Text2);
  78.             i++;
  79.         }
  80.     }
  81.  
  82.     strcpy (ChgWord[i].wad1, "");
  83.     strcpy (ChgDir[j].wad1, "");
  84.  
  85.     fclose (mapfile);
  86.     return (0);
  87. }
  88.  
  89.  
  90. void ConvertSideDefs (FILE *wad, long int start, long int entries)
  91. {
  92.     struct SideDef *Side_Def = GetMemory( sizeof( struct SideDef));
  93.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  94.     long int i, j, k;
  95.  
  96.     fseek (wad, start, SEEK_SET);
  97.  
  98.     for (i = 0; i < entries; i++)
  99.     {
  100.         fread (Side_Def, sizeof( struct SideDef), 1, wad);
  101.  
  102.         strncpy (buf, Side_Def->tex1, 8);
  103.         for (j = 0; strlen (ChgWord[j].wad1); j++)
  104.         {
  105.             if (strcmp (buf, ChgWord[j].wad1) == 0)
  106.             {
  107.                 strcpy (buf, ChgWord[j].wad2);
  108.                 for (k = strlen(buf); k < 8; k++)
  109.                     buf[k] = 0;
  110.  
  111.                 fseek (wad, -26, SEEK_CUR);
  112.                 for (k = 0; k < 8; k++)
  113.                     putc (buf[k], wad);
  114.                 fseek (wad, 18, SEEK_CUR);
  115.  
  116.                 printf ("\rconverting...   %8s --> %-8s", ChgWord[j].wad1, buf);
  117.                 break;
  118.             }
  119.         }
  120.  
  121.         strncpy (buf, Side_Def->tex2, 8);
  122.         for (j = 0; strlen (ChgWord[j].wad1); j++)
  123.         {
  124.             if (strcmp (buf, ChgWord[j].wad1) == 0)
  125.             {
  126.                 strcpy (buf, ChgWord[j].wad2);
  127.                 for (k = strlen(buf); k < 8; k++)
  128.                     buf[k] = 0;
  129.  
  130.                 fseek (wad, -18, SEEK_CUR);
  131.                 for (k = 0; k < 8; k++)
  132.                     putc (buf[k], wad);
  133.                 fseek (wad, 10, SEEK_CUR);
  134.  
  135.                 printf ("\rconverting...   %8s --> %-8s", ChgWord[j].wad1, buf);
  136.                 break;
  137.             }
  138.         }
  139.  
  140.         strncpy (buf, Side_Def->tex3, 8);
  141.         for (j = 0; strlen (ChgWord[j].wad1); j++)
  142.         {
  143.             if (strcmp (buf, ChgWord[j].wad1) == 0)
  144.             {
  145.                 strcpy (buf, ChgWord[j].wad2);
  146.                 for (k = strlen(buf); k < 8; k++)
  147.                     buf[k] = 0;
  148.  
  149.                 fseek (wad, -10, SEEK_CUR);
  150.                 for (k = 0; k < 8; k++)
  151.                     putc (buf[k], wad);
  152.                 fseek (wad, 2, SEEK_CUR);
  153.  
  154.                 printf ("\rconverting...   %8s --> %-8s", ChgWord[j].wad1, buf);
  155.                 break;
  156.             }
  157.         }
  158.     }
  159.     free (Side_Def);
  160.     printf ("\r\n");
  161. }
  162.  
  163.  
  164. void ConvertSectors (FILE *wad, long int start, long int entries)
  165. {
  166.     struct Sector *SectorI = GetMemory( sizeof( struct Sector));
  167.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  168.     long int i, j, k;
  169.  
  170.     fseek (wad, start, SEEK_SET);
  171.  
  172.     for (i = 0; i < entries; i++)
  173.     {
  174.         fread (SectorI, sizeof( struct Sector), 1, wad);
  175.  
  176.         strncpy (buf, SectorI->floort, 8);
  177.         for (j = 0; strlen (ChgWord[j].wad1); j++)
  178.         {
  179.             if (strcmp (buf, ChgWord[j].wad1) == 0)
  180.             {
  181.                 strcpy (buf, ChgWord[j].wad2);
  182.                 for (k = strlen(buf); k < 8; k++)
  183.                     buf[k] = 0;
  184.  
  185.                 fseek (wad, -22, SEEK_CUR);
  186.                 for (k = 0; k < 8; k++)
  187.                     putc (buf[k], wad);
  188.                 fseek (wad, 14, SEEK_CUR);
  189.  
  190.                 printf ("\rconverting...   %8s --> %-8s", ChgWord[j].wad1, buf);
  191.                 break;
  192.             }
  193.         }
  194.  
  195.         strncpy (buf, SectorI->ceilt, 8);
  196.         for (j = 0; strlen (ChgWord[j].wad1); j++)
  197.         {
  198.             if (strcmp (buf, ChgWord[j].wad1) == 0)
  199.             {
  200.                 strcpy (buf, ChgWord[j].wad2);
  201.                 for (k = strlen(buf); k < 8; k++)
  202.                     buf[k] = 0;
  203.  
  204.                 fseek (wad, -14, SEEK_CUR);
  205.                 for (k = 0; k < 8; k++)
  206.                     putc (buf[k], wad);
  207.                 fseek (wad, 6, SEEK_CUR);
  208.  
  209.                 printf ("\rconverting...   %8s --> %-8s", ChgWord[j].wad1, buf);
  210.                 break;
  211.             }
  212.         }
  213.     }
  214.     free (SectorI);
  215.     printf ("\r\n");
  216. }
  217.  
  218.  
  219. void ConvertThings (FILE *wad, long int start, long int entries)
  220. {
  221.     struct Thing *ThingI = GetMemory( sizeof( struct Thing));
  222.     long int i;
  223.     long int s = 0L;
  224.  
  225.     fseek (wad, start, SEEK_SET);
  226.  
  227.     for (i = 0; i < entries; i++)
  228.     {
  229.         fread (ThingI, sizeof( struct Thing), 1, wad);
  230.  
  231.         if (ThingI->type == 2001)
  232.         {
  233.             fseek (wad, -4, SEEK_CUR);
  234.             putc (0x52, wad);
  235.             putc (0x00, wad);
  236.             fseek (wad, 2, SEEK_CUR);
  237.             s++;
  238.         }
  239.  
  240.     }
  241.     free (ThingI);
  242.     printf ("converting...   %ld Shotguns\r\n", s);
  243. }
  244.  
  245.  
  246.  
  247. main (int argc, char *argv[])
  248. {
  249.     FILE *wad1, *wad2;
  250.     struct wad_header *wad2_hdr = GetMemory( sizeof( struct wad_header));
  251.     struct directory *dir_entry = GetMemory( sizeof( struct directory));
  252.     char buf[9] = "\0\0\0\0\0\0\0\0\0";
  253.     long int i, j, k, dir_pos;
  254.     int c;
  255.     char ConvertShotGun = 0;
  256.  
  257.  
  258.     for (i = 1; i < argc; i++)
  259.     {
  260.         if (strcmp (argv[i], "-s") == 0)
  261.         {
  262.             ConvertShotGun = 1;
  263.             for (j = i; j < (argc - 1); j++)
  264.             {
  265.                 argv[j] = argv[j + 1];
  266.             }
  267.             i--;
  268.             argc--;
  269.         }
  270.     }
  271.  
  272.     printf ("\r\n*** DOOM1 to DOOM2 pwad converter v1.0 (c) 1994 Tracy F. Thonn ***\r\n\n");
  273.     if (argc != 3 && argc != 4)
  274.     {
  275.         printf ("Usage:  WAD1TO2 <doom1.wad> <doom2.wad> {file.map} {-s}\r\n\n");
  276.         printf ("        doom1.wad ...input DOOM1 pwad file to be converted\r\n");
  277.         printf ("        doom2.wad ...output pwad file for use with DOOM2\r\n");
  278.         printf ("         file.map ...optional custom texture mapfile (default WAD1TO2.MAP)\r\n");
  279.         printf ("               -s ...option to convert Shotguns to Super Shotguns\r\n\n");
  280.         return (1);
  281.     }
  282.  
  283.     if (strcmp (argv[1], argv[2]) == 0)
  284.     {
  285.         printf ("\r\nError:  Output file is same as input file\r\n");
  286.         return (1);
  287.     }
  288.  
  289.     if (argc == 4)
  290.     {
  291.         if (LoadMapfile(argv[3]))
  292.             return (1);
  293.     }
  294.     else
  295.     {
  296.         if (LoadMapfile("WAD1TO2.MAP"))
  297.             return (1);
  298.     }
  299.  
  300.  
  301.     if (access (argv[2], 0) == 0)
  302.     {
  303.         printf ("\r\nWarning: %s already exists, Overwrite (y/n)?", argv[2]);
  304.         c = toupper(getche());
  305.         printf ("\r\n\r\n");
  306.         if (c != 'Y')
  307.             return (1);
  308.     }
  309.  
  310.     if ((wad1 = fopen(argv[1], "rb")) == NULL)
  311.     {
  312.         printf ("\r\nError:  Cannot open %s\r\n", argv[1]);
  313.         return (1);
  314.     }
  315.  
  316.     if ((wad2 = fopen(argv[2], "wb+")) == NULL)
  317.     {
  318.         printf ("\r\nError:  Cannot create %s\r\n", argv[2]);
  319.         fclose (wad1);
  320.         return (1);
  321.     }
  322.  
  323.  
  324.  
  325.     printf ("copying:  %s to %s\r\n", argv[1], argv[2]);
  326.     c = getc(wad1);
  327.     if (c != 'P')
  328.     {
  329.         printf ("\r\nError:  Input %s is not a pwad file\r\n", argv[1]);
  330.         fclose (wad1);
  331.         fclose (wad2);
  332.         return (1);
  333.     }
  334.     putc ('P', wad2);
  335.     while ((c = getc(wad1)) != EOF)
  336.         putc (c, wad2);
  337.     fclose (wad1);
  338.  
  339.     printf ("converting...\r\n");
  340.     fseek (wad2, 0L, SEEK_SET);
  341.     fread(wad2_hdr, sizeof( struct wad_header), 1, wad2);
  342.  
  343.     dir_pos = wad2_hdr->dir_start;
  344.  
  345.     for (i = 0; i < wad2_hdr->num_entries; i++)
  346.     {
  347.         fseek (wad2, dir_pos, SEEK_SET);
  348.         fread (dir_entry, sizeof( struct directory), 1, wad2);
  349.         dir_pos = ftell (wad2);
  350.  
  351.         strncpy (buf, dir_entry->name, 8);
  352.  
  353.         for (j = 0; strlen (ChgDir[j].wad1); j++)
  354.         {
  355.             if (strcmp (buf, ChgDir[j].wad1) == 0)
  356.             {
  357.                 strcpy (buf, ChgDir[j].wad2);
  358.                 for (k = strlen(buf); k < 8; k++)
  359.                     buf[k] = 0;
  360.  
  361.                 fseek (wad2, -8, SEEK_CUR);
  362.                 for (k = 0; k < 8; k++)
  363.                     putc (buf[k], wad2);
  364.  
  365.                 printf ("converting...   %8s --> %-8s\r\n", ChgDir[j].wad1, buf);
  366.                 break;
  367.             }
  368.         }
  369.  
  370.  
  371.         if (strcmp (buf, "SIDEDEFS") == 0)
  372.             ConvertSideDefs (wad2, dir_entry->start, (dir_entry->length) / sizeof(struct SideDef));
  373.  
  374.         if (strcmp (buf, "SECTORS") == 0)
  375.             ConvertSectors (wad2, dir_entry->start, (dir_entry->length) / sizeof(struct Sector));
  376.  
  377.         if (ConvertShotGun && (strcmp (buf, "THINGS") == 0))
  378.             ConvertThings (wad2, dir_entry->start, (dir_entry->length) / sizeof(struct Thing));
  379.     }
  380.  
  381.  
  382.     fclose (wad2);
  383.     return (0);
  384. }
  385.