home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #1 / monster.zip / monster / GAMES_C / DEU50.ZIP / SOURCE.ZIP / LEVELS.C < prev    next >
C/C++ Source or Header  |  1994-03-30  |  28KB  |  991 lines
  1. /*
  2.    Doom Editor Utility, by Brendon Wyber and Raphaël Quinet.
  3.  
  4.    You are allowed to use any parts of this code in another program, as
  5.    long as you give credits to the authors in the documentation and in
  6.    the program itself.  Read the file README.1ST for more information.
  7.  
  8.    This program comes with absolutely no warranty.
  9.  
  10.    LEVELS.C - Level loading and saving routines.
  11. */
  12.  
  13. /* the includes */
  14. #include "deu.h"
  15. #include "wstructs.h"
  16. #include "things.h"
  17.  
  18. /* external function from objects.c */
  19. extern NPtr CreateNodes( SEPtr);
  20.  
  21. /* the global data */
  22. MDirPtr Level = NULL;        /* master dictionary entry for the level */
  23. int NumThings = 0;        /* number of things */
  24. TPtr Things;            /* things data */
  25. int NumLineDefs = 0;        /* number of line defs */
  26. LDPtr LineDefs;            /* line defs data */
  27. int NumSideDefs = 0;        /* number of side defs */
  28. SDPtr SideDefs;            /* side defs data */
  29. int NumVertexes = 0;        /* number of vertexes */
  30. VPtr Vertexes;            /* vertex data */
  31. int NumSectors = 0;        /* number of sectors */
  32. SPtr Sectors;            /* sectors data */
  33. int NumSegs = 0;        /* number of segments */
  34. SEPtr Segs = NULL;        /* list of segments */
  35. SEPtr LastSeg = NULL;        /* last segment in the list */
  36. int NumSSectors = 0;        /* number of subsectors */
  37. SSPtr SSectors = NULL;        /* list of subsectors */
  38. SSPtr LastSSector = NULL;    /* last subsector in the list */
  39. int NumNodes = 0;        /* number of Nodes */
  40. NPtr Nodes = NULL;        /* nodes tree */
  41. int NumWTexture = 0;        /* number of wall textures */
  42. char **WTexture;        /* array of wall texture names */
  43. int NumFTexture = 0;        /* number of floor/ceiling textures */
  44. char **FTexture;        /* array of texture names */
  45. int MapMaxX = -32768;        /* maximum X value of map */
  46. int MapMaxY = -32768;        /* maximum Y value of map */
  47. int MapMinX = 32767;        /* minimum X value of map */
  48. int MapMinY = 32767;        /* minimum Y value of map */
  49. Bool MadeChanges = FALSE;    /* made changes? */
  50. Bool MadeMapChanges = FALSE;    /* made changes that need rebuilding? */
  51.  
  52.  
  53. /*
  54.    read in the level data
  55. */
  56.  
  57. void ReadLevelData( int episode, int level)
  58. {
  59.    MDirPtr dir;
  60.    char name[ 7];
  61.    int n, m;
  62.    int val;
  63.    int OldNumVertexes;
  64.    int *VertexUsed;
  65.  
  66.    /* find the various level information from the master directory */
  67.    sprintf( name, "E%dM%d", episode, level);
  68.    DisplayMessage( -1, -1, "Reading data for level %s...", name);
  69.    Level = FindMasterDir( MasterDir, name);
  70.    if (!Level)
  71.       ProgError( "level data not found");
  72.  
  73.    /* get the number of Vertices */
  74.    dir = FindMasterDir( Level, "VERTEXES");
  75.    OldNumVertexes = (int) (dir->dir.size / 4L);
  76.    if (OldNumVertexes > 0)
  77.    {
  78.       VertexUsed = GetMemory( OldNumVertexes * sizeof( int));
  79.       for (n = 0; n < OldNumVertexes; n++)
  80.      VertexUsed[ n] = FALSE;
  81.    }
  82.  
  83.    /* read in the Things data */
  84.    dir = FindMasterDir( Level, "THINGS");
  85.    NumThings = (int) (dir->dir.size / 10L);
  86.    if (NumThings > 0)
  87.    {
  88.       Things = GetFarMemory( (unsigned long) NumThings * sizeof( struct Thing));
  89.       BasicWadSeek( dir->wadfile, dir->dir.start);
  90.       for (n = 0; n < NumThings; n++)
  91.       {
  92.      BasicWadRead( dir->wadfile, &(Things[ n].xpos), 2);
  93.      BasicWadRead( dir->wadfile, &(Things[ n].ypos), 2);
  94.      BasicWadRead( dir->wadfile, &(Things[ n].angle), 2);
  95.      BasicWadRead( dir->wadfile, &(Things[ n].type), 2);
  96.      BasicWadRead( dir->wadfile, &(Things[ n].when), 2);
  97.       }
  98.    }
  99.  
  100.    /* read in the LineDef information */
  101.    dir = FindMasterDir( Level, "LINEDEFS");
  102.    NumLineDefs = (int) (dir->dir.size / 14L);
  103.    if (NumLineDefs > 0)
  104.    {
  105.       LineDefs = GetFarMemory( (unsigned long) NumLineDefs * sizeof( struct LineDef));
  106.       BasicWadSeek( dir->wadfile, dir->dir.start);
  107.       for (n = 0; n < NumLineDefs; n++)
  108.       {
  109.      BasicWadRead( dir->wadfile, &(LineDefs[ n].start), 2);
  110.      VertexUsed[ LineDefs[ n].start] = TRUE;
  111.      BasicWadRead( dir->wadfile, &(LineDefs[ n].end), 2);
  112.      VertexUsed[ LineDefs[ n].end] = TRUE;
  113.      BasicWadRead( dir->wadfile, &(LineDefs[ n].flags), 2);
  114.      BasicWadRead( dir->wadfile, &(LineDefs[ n].type), 2);
  115.      BasicWadRead( dir->wadfile, &(LineDefs[ n].tag), 2);
  116.      BasicWadRead( dir->wadfile, &(LineDefs[ n].sidedef1), 2);
  117.      BasicWadRead( dir->wadfile, &(LineDefs[ n].sidedef2), 2);
  118.       }
  119.    }
  120.  
  121.    /* read in the SideDef information */
  122.    dir = FindMasterDir( Level, "SIDEDEFS");
  123.    NumSideDefs = (int) (dir->dir.size / 30L);
  124.    if (NumSideDefs > 0)
  125.    {
  126.       SideDefs = GetFarMemory( (unsigned long) NumSideDefs * sizeof( struct SideDef));
  127.       BasicWadSeek( dir->wadfile, dir->dir.start);
  128.       for (n = 0; n < NumSideDefs; n++)
  129.       {
  130.      BasicWadRead( dir->wadfile, &(SideDefs[ n].xoff), 2);
  131.      BasicWadRead( dir->wadfile, &(SideDefs[ n].yoff), 2);
  132.      BasicWadRead( dir->wadfile, &(SideDefs[ n].tex1), 8);
  133.      BasicWadRead( dir->wadfile, &(SideDefs[ n].tex2), 8);
  134.      BasicWadRead( dir->wadfile, &(SideDefs[ n].tex3), 8);
  135.      BasicWadRead( dir->wadfile, &(SideDefs[ n].sector), 2);
  136.       }
  137.    }
  138.  
  139.    /* read in the Vertices which are all the corners of the level, but ignore the */
  140.    /* Vertices not used in any LineDef (they usually are at the end of the list). */
  141.    NumVertexes = 0;
  142.    for (n = 0; n < OldNumVertexes; n++)
  143.       if (VertexUsed[ n])
  144.      NumVertexes++;
  145.    if (NumVertexes > 0)
  146.    {
  147.       Vertexes = GetFarMemory( (unsigned long) NumVertexes * sizeof( struct Vertex));
  148.       dir = FindMasterDir( Level, "VERTEXES");
  149.       BasicWadSeek( dir->wadfile, dir->dir.start);
  150.       MapMaxX = -32768;
  151.       MapMaxY = -32768;
  152.       MapMinX = 32767;
  153.       MapMinY = 32767;
  154.       m = 0;
  155.       for (n = 0; n < OldNumVertexes; n++)
  156.       {
  157.      BasicWadRead( dir->wadfile, &val, 2);
  158.      if (VertexUsed[ n])
  159.      {
  160.         if (val < MapMinX)
  161.            MapMinX = val;
  162.         if (val > MapMaxX)
  163.            MapMaxX = val;
  164.         Vertexes[ m].x = val;
  165.      }
  166.      BasicWadRead( dir->wadfile, &val, 2);
  167.      if (VertexUsed[ n])
  168.      {
  169.         if (val < MapMinY)
  170.            MapMinY = val;
  171.         if (val > MapMaxY)
  172.            MapMaxY = val;
  173.         Vertexes[ m].y = val;
  174.         m++;
  175.      }
  176.       }
  177.       if (m != NumVertexes)
  178.      ProgError("inconsistency in the Vertexes data\n");
  179.    }
  180.  
  181.    if (OldNumVertexes > 0)
  182.    {
  183.       /* update the Vertex numbers in the LineDefs (not really necessary, but...) */
  184.       m = 0;
  185.       for (n = 0; n < OldNumVertexes; n++)
  186.      if (VertexUsed[ n])
  187.         VertexUsed[ n] = m++;
  188.       for (n = 0; n < NumLineDefs; n++)
  189.       {
  190.      LineDefs[ n].start = VertexUsed[ LineDefs[ n].start];
  191.      LineDefs[ n].end = VertexUsed[ LineDefs[ n].end];
  192.       }
  193.       free( VertexUsed);
  194.    }
  195.  
  196.    /* ignore the Segs, SSectors and Nodes */
  197.  
  198.    /* read in the Sectors information */
  199.    dir = FindMasterDir( Level, "SECTORS");
  200.    NumSectors = (int) (dir->dir.size / 26L);
  201.    if (NumSectors > 0)
  202.    {
  203.       Sectors = GetFarMemory( (unsigned long) NumSectors * sizeof( struct Sector));
  204.       BasicWadSeek( dir->wadfile, dir->dir.start);
  205.       for (n = 0; n < NumSectors; n++)
  206.       {
  207.      BasicWadRead( dir->wadfile, &(Sectors[ n].floorh), 2);
  208.      BasicWadRead( dir->wadfile, &(Sectors[ n].ceilh), 2);
  209.      BasicWadRead( dir->wadfile, &(Sectors[ n].floort), 8);
  210.      BasicWadRead( dir->wadfile, &(Sectors[ n].ceilt), 8);
  211.      BasicWadRead( dir->wadfile, &(Sectors[ n].light), 2);
  212.      BasicWadRead( dir->wadfile, &(Sectors[ n].special), 2);
  213.      BasicWadRead( dir->wadfile, &(Sectors[ n].tag), 2);
  214.       }
  215.    }
  216.  
  217.    /* ignore the last entries (Reject & BlockMap) */
  218. }
  219.  
  220.  
  221.  
  222. /*
  223.    forget the level data
  224. */
  225.  
  226. void ForgetLevelData()
  227. {
  228.    /* forget the Things */
  229.    NumThings = 0;
  230.    if (Things)
  231.       farfree( Things);
  232.    Things = NULL;
  233.  
  234.    /* forget the LineDefs */
  235.    NumLineDefs = 0;
  236.    if (LineDefs)
  237.       farfree( LineDefs);
  238.    LineDefs = NULL;
  239.  
  240.    /* forget the SideDefs */
  241.    NumSideDefs = 0;
  242.    if (SideDefs)
  243.       farfree( SideDefs);
  244.    SideDefs = NULL;
  245.  
  246.    /* forget the Vertices */
  247.    NumVertexes = 0;
  248.    if (Vertexes)
  249.       farfree( Vertexes);
  250.    Vertexes = NULL;
  251.  
  252.    /* forget the Sectors */
  253.    NumSectors = 0;
  254.    if (Sectors)
  255.       farfree( Sectors);
  256.    Sectors = NULL;
  257. }
  258.  
  259.  
  260.  
  261. /*
  262.    recursively save the Nodes data to a PWAD file
  263. */
  264.  
  265. void SaveNodes( FILE *file, NPtr node)
  266. {
  267.    /* Nodes tree walk: save child1, save child2, save parent */
  268.    if ((node->child1 & 0x8000) == 0)
  269.    {
  270.       SaveNodes( file, node->node1);
  271.       node->child1 = node->node1->num;
  272.    }
  273.    if ((node->child2 & 0x8000) == 0)
  274.    {
  275.       SaveNodes( file, node->node2);
  276.       node->child2 = node->node2->num;
  277.    }
  278.    WriteBytes( file, &(node->x), 2L);
  279.    WriteBytes( file, &(node->y), 2L);
  280.    WriteBytes( file, &(node->dx), 2L);
  281.    WriteBytes( file, &(node->dy), 2L);
  282.    WriteBytes( file, &(node->maxy1), 2L);
  283.    WriteBytes( file, &(node->miny1), 2L);
  284.    WriteBytes( file, &(node->minx1), 2L);
  285.    WriteBytes( file, &(node->maxx1), 2L);
  286.    WriteBytes( file, &(node->maxy2), 2L);
  287.    WriteBytes( file, &(node->miny2), 2L);
  288.    WriteBytes( file, &(node->minx2), 2L);
  289.    WriteBytes( file, &(node->maxx2), 2L);
  290.    WriteBytes( file, &(node->child1), 2L);
  291.    WriteBytes( file, &(node->child2), 2L);
  292.    node->num = NumNodes++;
  293. }
  294.  
  295.  
  296.  
  297. /*
  298.    forget the Nodes
  299. */
  300.  
  301. void ForgetNodes( NPtr node)
  302. {
  303.    if ((node->child1 & 0x8000) == 0)
  304.       ForgetNodes( node->node1);
  305.    if ((node->child2 & 0x8000) == 0)
  306.       ForgetNodes( node->node2);
  307.    farfree( node);
  308. }
  309.  
  310.  
  311.  
  312. /*
  313.    save the level data to a PWAD file
  314. */
  315.  
  316. void SaveLevelData( char *outfile)
  317. {
  318.    FILE   *file;
  319.    MDirPtr dir;
  320.    long    counter = 11;
  321.    int     n, i, j;
  322.    void   *data;
  323.    long    size;
  324.    long    dirstart;
  325.    int    *blockptr;
  326.    long    blocksize;
  327.    int     blockcount;
  328.    long    oldpos;
  329.    Bool    newnodes;
  330.    long    rejectsize;
  331.  
  332.    DisplayMessage( -1, -1, "Saving data to \"%s\"...", outfile);
  333.    /* open the file */
  334.    if ((file = fopen( outfile, "wb")) == NULL)
  335.       ProgError( "Unable to open file \"%s\"", outfile);
  336.    WriteBytes( file, "PWAD", 4L);     /* PWAD file */
  337.    WriteBytes( file, &counter, 4L);   /* 11 entries */
  338.    WriteBytes( file, &counter, 4L);   /* fix this up later */
  339.    counter = 12L;
  340.    dir = Level->next;
  341.  
  342.    /* output the things data */
  343.    for (n = 0; n < NumThings; n++)
  344.    {
  345.       WriteBytes( file, &(Things[ n].xpos), 2L);
  346.       WriteBytes( file, &(Things[ n].ypos), 2L);
  347.       WriteBytes( file, &(Things[ n].angle), 2L);
  348.       WriteBytes( file, &(Things[ n].type), 2L);
  349.       WriteBytes( file, &(Things[ n].when), 2L);
  350.       counter += 10L;
  351.    }
  352.    dir = dir->next;
  353.  
  354.    /* update MapMinX, MapMinY, MapMaxX, MapMaxY */
  355.    MapMaxX = -32768;
  356.    MapMaxY = -32768;
  357.    MapMinX = 32767;
  358.    MapMinY = 32767;
  359.    for (n = 0; n < NumVertexes; n++)
  360.    {
  361.       if (Vertexes[ n].x < MapMinX)
  362.      MapMinX = Vertexes[ n].x;
  363.       if (Vertexes[ n].x > MapMaxX)
  364.      MapMaxX = Vertexes[ n].x;
  365.       if (Vertexes[ n].y < MapMinY)
  366.      MapMinY = Vertexes[ n].y;
  367.       if (Vertexes[ n].y > MapMaxY)
  368.      MapMaxY = Vertexes[ n].y;
  369.    }
  370.  
  371.    /* do we need to rebuild the Nodes, Segs and SSectors? */
  372.    if (MadeMapChanges && (Expert || Confirm( -1, 270, "Do you want to rebuild the NODES, SEGS, SSECTORS, REJECT and BLOCKMAP?",
  373.                               "WARNING: You won't be able to use your level if you don't do this...")))
  374.    {
  375.       SEPtr seglist, lastseg;
  376.  
  377.       if (UseMouse)
  378.      HideMousePointer();
  379.       ClearScreen();
  380.       DrawScreenBox3D( 218, 0, ScrMaxX, 55);
  381.       SetColor( WHITE);
  382.       DrawScreenText( 225, 10, "Rebuilding the NODES...");
  383.       DrawScreenBoxHollow( 225, 28, ScrMaxX - 10, 48);
  384.       DrawScreenMeter( 225, 28, ScrMaxX - 10, 48, 0.0);
  385.       if (UseMouse)
  386.      ShowMousePointer();
  387.       seglist = NULL;
  388.       for (n = 0; n < NumLineDefs; n++)
  389.       {
  390.      if (LineDefs[ n].sidedef1 >= 0)
  391.      {
  392.         if (seglist)
  393.         {
  394.            LastSeg->next = GetMemory( sizeof( struct Seg));
  395.            LastSeg = LastSeg->next;
  396.         }
  397.         else
  398.         {
  399.            seglist = GetMemory( sizeof( struct Seg));
  400.            LastSeg = seglist;
  401.         }
  402.         LastSeg->next = NULL;
  403.         LastSeg->start = LineDefs[ n].start;
  404.         LastSeg->end = LineDefs[ n].end;
  405.         LastSeg->angle = ComputeAngle(Vertexes[ LineDefs[ n].end].x - Vertexes[ LineDefs[ n].start].x,
  406.                       Vertexes[ LineDefs[ n].end].y - Vertexes[ LineDefs[ n].start].y);
  407.         LastSeg->linedef = n;
  408.         LastSeg->flip = 0;
  409.         LastSeg->dist = 0;
  410.      }
  411.      if (LineDefs[ n].sidedef2 >= 0)
  412.      {
  413.         if (seglist)
  414.         {
  415.            LastSeg->next = GetMemory( sizeof( struct Seg));
  416.            LastSeg = LastSeg->next;
  417.         }
  418.         else
  419.         {
  420.            seglist = GetMemory( sizeof( struct Seg));
  421.            LastSeg = seglist;
  422.         }
  423.         LastSeg->next = NULL;
  424.         LastSeg->start = LineDefs[ n].end;
  425.         LastSeg->end = LineDefs[ n].start;
  426.         LastSeg->angle = ComputeAngle(Vertexes[ LineDefs[ n].start].x - Vertexes[ LineDefs[ n].end].x,
  427.                       Vertexes[ LineDefs[ n].start].y - Vertexes[ LineDefs[ n].end].y);
  428.         LastSeg->linedef = n;
  429.         LastSeg->flip = 1;
  430.         LastSeg->dist = 0;
  431.      }
  432.       }
  433.       ShowProgress( OBJ_VERTEXES);
  434.       ShowProgress( OBJ_SIDEDEFS);
  435.       Nodes = CreateNodes( seglist);
  436.       DrawScreenMeter( 225, 28, ScrMaxX - 10, 48, 1.0);
  437.       newnodes = TRUE;
  438.    }
  439.    else
  440.       newnodes = FALSE;
  441.  
  442.    /* output the LineDefs */
  443.    for (n = 0; n < NumLineDefs; n++)
  444.    {
  445.       WriteBytes( file, &(LineDefs[ n].start), 2L);
  446.       WriteBytes( file, &(LineDefs[ n].end), 2L);
  447.       WriteBytes( file, &(LineDefs[ n].flags), 2L);
  448.       WriteBytes( file, &(LineDefs[ n].type), 2L);
  449.       WriteBytes( file, &(LineDefs[ n].tag), 2L);
  450.       WriteBytes( file, &(LineDefs[ n].sidedef1), 2L);
  451.       WriteBytes( file, &(LineDefs[ n].sidedef2), 2L);
  452.       counter += 14L;
  453.    }
  454.    dir = dir->next;
  455.  
  456.    /* output the SideDefs */
  457.    for (n = 0; n < NumSideDefs; n++)
  458.    {
  459.       WriteBytes( file, &(SideDefs[ n].xoff), 2L);
  460.       WriteBytes( file, &(SideDefs[ n].yoff), 2L);
  461.       WriteBytes( file, &(SideDefs[ n].tex1), 8L);
  462.       WriteBytes( file, &(SideDefs[ n].tex2), 8L);
  463.       WriteBytes( file, &(SideDefs[ n].tex3), 8L);
  464.       WriteBytes( file, &(SideDefs[ n].sector), 2L);
  465.       counter += 30L;
  466.    }
  467.    dir = dir->next;
  468.  
  469.    if (MadeMapChanges)
  470.    {
  471.       /* output the Vertices */
  472.       for (n = 0; n < NumVertexes; n++)
  473.       {
  474.      WriteBytes( file, &(Vertexes[ n].x), 2L);
  475.      WriteBytes( file, &(Vertexes[ n].y), 2L);
  476.      counter += 4L;
  477.       }
  478.    }
  479.    else
  480.    {
  481.       /* copy the Vertices */
  482.       data = GetMemory( 0x8000 + 2);
  483.       size = dir->dir.size;
  484.       counter += size;
  485.       BasicWadSeek( dir->wadfile, dir->dir.start);
  486.       while (size > 0x8000)
  487.       {
  488.      BasicWadRead( dir->wadfile, data, 0x8000);
  489.      WriteBytes( file, data, 0x8000);
  490.      size -= 0x8000;
  491.       }
  492.       BasicWadRead( dir->wadfile, data, size);
  493.       WriteBytes( file, data, size);
  494.       free( data);
  495.    }
  496.    dir = dir->next;
  497.  
  498.    if (newnodes)
  499.    {
  500.       SEPtr curse, oldse;
  501.       SSPtr curss, oldss;
  502.  
  503.       /* output and forget the Segments */
  504.       curse = Segs;
  505.       while (curse)
  506.       {
  507.      WriteBytes( file, &(curse->start), 2L);
  508.      WriteBytes( file, &(curse->end), 2L);
  509.      WriteBytes( file, &(curse->angle), 2L);
  510.      WriteBytes( file, &(curse->linedef), 2L);
  511.      WriteBytes( file, &(curse->flip), 2L);
  512.      WriteBytes( file, &(curse->dist), 2L);
  513.      oldse = curse;
  514.      curse = curse->next;
  515.      farfree( oldse);
  516.      counter += 12L;
  517.       }
  518.       Segs = NULL;
  519.       dir = dir->next;
  520.  
  521.       /* output and forget the SSectors */
  522.       curss = SSectors;
  523.       while (curss)
  524.       {
  525.      WriteBytes( file, &(curss->num), 2L);
  526.      WriteBytes( file, &(curss->first), 2L);
  527.      oldss = curss;
  528.      curss = curss->next;
  529.      farfree( oldss);
  530.      counter += 4L;
  531.       }
  532.       SSectors = NULL;
  533.       dir = dir->next;
  534.  
  535.       /* output the Nodes */
  536.       NumNodes = 0;
  537.       SaveNodes( file, Nodes);
  538.       counter += (long) NumNodes * 28L;
  539.       dir = dir->next;
  540.  
  541.       /* forget the Nodes */
  542.       ForgetNodes( Nodes);
  543.       Nodes = NULL;
  544.    }
  545.    else
  546.    {
  547.       /* copy the Segs, SSectors and Nodes */
  548.       data = GetMemory( 0x8000 + 2);
  549.       for (n = 0; n < 3; n++)
  550.       {
  551.      size = dir->dir.size;
  552.      counter += size;
  553.      BasicWadSeek( dir->wadfile, dir->dir.start);
  554.      while (size > 0x8000)
  555.      {
  556.         BasicWadRead( dir->wadfile, data, 0x8000);
  557.         WriteBytes( file, data, 0x8000);
  558.         size -= 0x8000;
  559.      }
  560.      BasicWadRead( dir->wadfile, data, size);
  561.      WriteBytes( file, data, size);
  562.      dir = dir->next;
  563.       }
  564.       free( data);
  565.    }
  566.  
  567.    /* output the Sectors */
  568.    for (n = 0; n < NumSectors; n++)
  569.    {
  570.       WriteBytes( file, &(Sectors[ n].floorh), 2L);
  571.       WriteBytes( file, &(Sectors[ n].ceilh), 2L);
  572.       WriteBytes( file, &(Sectors[ n].floort), 8L);
  573.       WriteBytes( file, &(Sectors[ n].ceilt), 8L);
  574.       WriteBytes( file, &(Sectors[ n].light), 2L);
  575.       WriteBytes( file, &(Sectors[ n].special), 2L);
  576.       WriteBytes( file, &(Sectors[ n].tag), 2L);
  577.       counter += 26L;
  578.    }
  579.    dir = dir->next;
  580.  
  581.    if (newnodes)
  582.    {
  583.       /* create and output the reject data */
  584.       if (UseMouse)
  585.      HideMousePointer();
  586.       DrawScreenBox3D( 218, 80, ScrMaxX, 135);
  587.       SetColor( WHITE);
  588.       DrawScreenText( 225, 90, "Rebuilding the REJECT data...");
  589.       DrawScreenBoxHollow( 225, 108, ScrMaxX - 10, 128);
  590.       DrawScreenMeter( 225, 108, ScrMaxX - 10, 128, 0.0);
  591.       if (UseMouse)
  592.      ShowMousePointer();
  593.       rejectsize = ((long) NumSectors * (long) NumSectors + 7L) / 8L;
  594.       data = GetMemory( (size_t) rejectsize);
  595.       for (i = 0; i < rejectsize; i++)
  596.      ((char *) data)[ i] = 0;
  597.       for (i = 0; i < NumSectors; i++)
  598.       {
  599.      DrawScreenMeter( 225, 108, ScrMaxX - 10, 128, (float) i / (float) NumSectors);
  600.      for (j = 0; j < NumSectors; j++)
  601.      {
  602. /*
  603.         if (Reject( i, j))
  604.            data[ (i * NumSectors + j) / 8] |= 1 <<
  605. */
  606.      }
  607.       }
  608.       DrawScreenMeter( 225, 108, ScrMaxX - 10, 128, 1.0);
  609.       WriteBytes( file, data, rejectsize);
  610.       counter += rejectsize;
  611.       dir = dir->next;
  612.       free( data);
  613.    }
  614.    else
  615.    {
  616.       /* copy the Reject data */
  617.       rejectsize = dir->dir.size;
  618.       data = GetMemory( 0x8000 + 2);
  619.       size = rejectsize;
  620.       counter += size;
  621.       BasicWadSeek( dir->wadfile, dir->dir.start);
  622.       while (size > 0x8000)
  623.       {
  624.      BasicWadRead( dir->wadfile, data, 0x8000);
  625.      WriteBytes( file, data, 0x8000);
  626.      size -= 0x8000;
  627.       }
  628.       BasicWadRead( dir->wadfile, data, size);
  629.       WriteBytes( file, data, size);
  630.       dir = dir->next;
  631.       free( data);
  632.    }
  633.  
  634.    if (newnodes)
  635.    {
  636.       /* create and output the blockmap */
  637.       if (UseMouse)
  638.      HideMousePointer();
  639.       DrawScreenBox3D( 218, 160, ScrMaxX, 215);
  640.       SetColor( WHITE);
  641.       DrawScreenText( 225, 170, "Rebuilding the BLOCKMAP...");
  642.       DrawScreenBoxHollow( 225, 188, ScrMaxX - 10, 208);
  643.       DrawScreenMeter( 225, 188, ScrMaxX - 10, 208, 0.0);
  644.       if (UseMouse)
  645.      ShowMousePointer();
  646.       MapMinX = (int) (MapMinX / 8 - 8) * 8;
  647.       WriteBytes( file, &MapMinX, 2L);
  648.       MapMinY = (int) (MapMinY / 8 - 8) * 8;
  649.       WriteBytes( file, &MapMinY, 2L);
  650.       MapMaxX = MapMaxX / 128 - MapMinX / 128 + 2;
  651.       WriteBytes( file, &MapMaxX, 2L);
  652.       MapMaxY = MapMaxY / 128 - MapMinY / 128 + 2;
  653.       WriteBytes( file, &MapMaxY, 2L);
  654.       counter += 8L;
  655.       oldpos = ftell( file);
  656.       blocksize = (long) (MapMaxX * MapMaxY * sizeof( int));
  657.       blockptr = GetMemory( blocksize);
  658.       WriteBytes( file, blockptr, blocksize);
  659.       blocksize += 8L;
  660.       counter += blocksize - 7L;
  661.       blockcount = MapMaxX * MapMaxY + 4;
  662.       for (i = 0; i < MapMaxY; i++)
  663.       {
  664.      DrawScreenMeter( 225, 188, ScrMaxX - 10, 208, (float) i / (float) MapMaxY);
  665.      for (j = 0; j < MapMaxX; j++)
  666.      {
  667.         blockptr[ MapMaxX * i + j] = blockcount;
  668.         n = 0;
  669.         WriteBytes( file, &n, 2L);
  670.         counter += 2L;
  671.         blocksize += 2L;
  672.         blockcount++;
  673.         for (n = 0; n < NumLineDefs; n++)
  674.            if (IsLineDefInside( n, MapMinX + j * 128, MapMinY + i * 128, MapMinX + 127 + j * 128, MapMinY + 127 + i * 128))
  675.            {
  676.           WriteBytes( file, &n, 2L);
  677.           counter += 2L;
  678.           blocksize += 2L;
  679.           blockcount++;
  680.            }
  681.         n = -1;
  682.         WriteBytes( file, &n, 2L);
  683.         counter += 2L;
  684.         blocksize += 2L;
  685.         blockcount++;
  686.      }
  687.       }
  688.       DrawScreenMeter( 225, 188, ScrMaxX - 10, 208, 1.0);
  689.       size = ftell( file);
  690.       fseek( file, oldpos, SEEK_SET);
  691.       WriteBytes( file, blockptr, (long) (MapMaxX * MapMaxY * sizeof( int)));
  692.       fseek( file, size, SEEK_SET);
  693.       if (FindMasterDir( dir, "P2_END"))
  694.      counter--;
  695.       free( blockptr);
  696.    }
  697.    else
  698.    {
  699.       /* copy the blockmap data */
  700.       blocksize = dir->dir.size;
  701.       data = GetMemory( 0x8000 + 2);
  702.       size = blocksize;
  703.       counter += size;
  704.       BasicWadSeek( dir->wadfile, dir->dir.start);
  705.       while (size > 0x8000)
  706.       {
  707.      BasicWadRead( dir->wadfile, data, 0x8000);
  708.      WriteBytes( file, data, 0x8000);
  709.      size -= 0x8000;
  710.       }
  711.       BasicWadRead( dir->wadfile, data, size);
  712.       WriteBytes( file, data, size);
  713.       dir = dir->next;
  714.       free( data);
  715.    }
  716.  
  717.    /* output the actual directory */
  718.    dirstart = counter;
  719.    counter = 12L;
  720.    size = 0L;
  721.    dir = Level;
  722.    WriteBytes( file, &counter, 4L);
  723.    WriteBytes( file, &size, 4L);
  724.    WriteBytes( file, &(dir->dir.name), 8L);
  725.    dir = dir->next;
  726.  
  727.    size = (long) NumThings * 10L;
  728.    WriteBytes( file, &counter, 4L);
  729.    WriteBytes( file, &size, 4L);
  730.    WriteBytes( file, "THINGS\0\0", 8L);
  731.    counter += size;
  732.    dir = dir->next;
  733.  
  734.    size = (long) NumLineDefs * 14L;
  735.    WriteBytes( file, &counter, 4L);
  736.    WriteBytes( file, &size, 4L);
  737.    WriteBytes( file, "LINEDEFS", 8L);
  738.    counter += size;
  739.    dir = dir->next;
  740.  
  741.    size = (long) NumSideDefs * 30L;
  742.    WriteBytes( file, &counter, 4L);
  743.    WriteBytes( file, &size, 4L);
  744.    WriteBytes( file, "SIDEDEFS", 8L);
  745.    counter += size;
  746.    dir = dir->next;
  747.  
  748.    if (newnodes)
  749.       size = (long) NumVertexes * 4L;
  750.    else
  751.       size = dir->dir.size;
  752.    WriteBytes( file, &counter, 4L);
  753.    WriteBytes( file, &size, 4L);
  754.    WriteBytes( file, "VERTEXES", 8L);
  755.    counter += size;
  756.    dir = dir->next;
  757.  
  758.    if (newnodes)
  759.       size = (long) NumSegs * 12L;
  760.    else
  761.       size = dir->dir.size;
  762.    WriteBytes( file, &counter, 4L);
  763.    WriteBytes( file, &size, 4L);
  764.    WriteBytes( file, "SEGS\0\0\0\0", 8L);
  765.    counter += size;
  766.    dir = dir->next;
  767.  
  768.    if (newnodes)
  769.       size = (long) NumSSectors * 4L;
  770.    else
  771.       size = dir->dir.size;
  772.    WriteBytes( file, &counter, 4L);
  773.    WriteBytes( file, &size, 4L);
  774.    WriteBytes( file, "SSECTORS", 8L);
  775.    counter += size;
  776.    dir = dir->next;
  777.  
  778.    if (newnodes)
  779.       size = (long) NumNodes * 28L;
  780.    else
  781.       size = dir->dir.size;
  782.    WriteBytes( file, &counter, 4L);
  783.    WriteBytes( file, &size, 4L);
  784.    WriteBytes( file, "NODES\0\0\0", 8L);
  785.    counter += size;
  786.    dir = dir->next;
  787.  
  788.    size = (long) NumSectors * 26L;
  789.    WriteBytes( file, &counter, 4L);
  790.    WriteBytes( file, &size, 4L);
  791.    WriteBytes( file, "SECTORS\0", 8L);
  792.    counter += size;
  793.    dir = dir->next;
  794.  
  795.    size = rejectsize;
  796.    WriteBytes( file, &counter, 4L);
  797.    WriteBytes( file, &size, 4L);
  798.    WriteBytes( file, "REJECT\0\0", 8L);
  799.    counter += size;
  800.    dir = dir->next;
  801.  
  802.    size = blocksize;
  803.    WriteBytes( file, &counter, 4L);
  804.    WriteBytes( file, &size, 4L);
  805.    WriteBytes( file, "BLOCKMAP", 8L);
  806.    counter += size;
  807.    dir = dir->next;
  808.  
  809.    /* fix up the directory start information */
  810.    if (fseek( file, 8L, SEEK_SET))
  811.       ProgError( "error writing to file");
  812.    WriteBytes( file, &dirstart, 4L);
  813.  
  814.    /* close the file */
  815.    fclose( file);
  816.  
  817.    NumSegs = 0;
  818.    NumSSectors = 0;
  819.    NumNodes = 0;
  820.  
  821.    /* update pointers in Master Directory */
  822.    OpenPatchWad( outfile);
  823.  
  824.    /* this should free the old "*.BAK" file */
  825.    CloseUnusedWadFiles();
  826. }
  827.  
  828.  
  829.  
  830. /*
  831.    function used by qsort to sort the texture names
  832. */
  833. int SortTextures( const void *a, const void *b)
  834. {
  835.    return strcmp( *((char **)a), *((char **)b));
  836. }
  837.  
  838.  
  839.  
  840. /*
  841.    read in the wall texture names
  842. */
  843.  
  844. void ReadWTextureNames()
  845. {
  846.    MDirPtr dir;
  847.    long *offsets;
  848.    int n;
  849.    long val;
  850.  
  851.    printf("Reading wall texture names\n");
  852.    dir = FindMasterDir( MasterDir, "TEXTURE1");
  853.    BasicWadSeek( dir->wadfile, dir->dir.start);
  854.    BasicWadRead( dir->wadfile, &val, 4);
  855.    NumWTexture = val + 1;
  856.    /* read in the offsets for texture1 names */
  857.    offsets = GetMemory( NumWTexture * sizeof( long));
  858.    for (n = 1; n < NumWTexture; n++)
  859.       BasicWadRead( dir->wadfile, &(offsets[ n]), 4);
  860.    /* read in the actual names */
  861.    WTexture = GetMemory( NumWTexture * sizeof( char *));
  862.    WTexture[ 0] = GetMemory( 9 * sizeof( char));
  863.    strcpy(WTexture[ 0], "-");
  864.    for (n = 1; n < NumWTexture; n++)
  865.    {
  866.       WTexture[ n] = GetMemory( 9 * sizeof( char));
  867.       BasicWadSeek( dir->wadfile, dir->dir.start + offsets[ n]);
  868.       BasicWadRead( dir->wadfile, WTexture[ n], 8);
  869.       WTexture[ n][ 8] = '\0';
  870.    }
  871.    free( offsets);
  872.    if (Registered)
  873.    {
  874.       dir = FindMasterDir( MasterDir, "TEXTURE2");
  875.       BasicWadSeek( dir->wadfile, dir->dir.start);
  876.       BasicWadRead( dir->wadfile, &val, 4);
  877.       /* read in the offsets for texture2 names */
  878.       offsets = GetMemory( val * sizeof( long));
  879.       for (n = 0; n < val; n++)
  880.      BasicWadRead( dir->wadfile, &(offsets[ n]), 4);
  881.       /* read in the actual names */
  882.       WTexture = ResizeMemory( WTexture, (NumWTexture + val) * sizeof( char *));
  883.       for (n = 0; n < val; n++)
  884.       {
  885.      WTexture[ NumWTexture + n] = GetMemory( 9 * sizeof( char));
  886.      BasicWadSeek( dir->wadfile, dir->dir.start + offsets[ n]);
  887.      BasicWadRead( dir->wadfile, WTexture[ NumWTexture + n], 8);
  888.      WTexture[ NumWTexture + n][ 8] = '\0';
  889.       }
  890.       NumWTexture += val;
  891.       free( offsets);
  892.    }
  893.    /* sort the names */
  894.    qsort( WTexture, NumWTexture, sizeof( char *), SortTextures);
  895. }
  896.  
  897.  
  898.  
  899. /*
  900.    forget the wall texture names
  901. */
  902.  
  903. void ForgetWTextureNames()
  904. {
  905.    int n;
  906.  
  907.    /* forget all names */
  908.    for (n = 0; n < NumWTexture; n++)
  909.       free( WTexture[ n]);
  910.  
  911.    /* forget the array */
  912.    NumWTexture = 0;
  913.    free( WTexture);
  914. }
  915.  
  916.  
  917.  
  918. /*
  919.    read in the floor/ceiling texture names
  920. */
  921.  
  922. void ReadFTextureNames()
  923. {
  924.    MDirPtr dir;
  925.    int n, m;
  926.  
  927.    printf("Reading floor/ceiling texture names\n");
  928.    /* count the names */
  929.    dir = FindMasterDir( MasterDir, "F1_START");
  930.    dir = dir->next;
  931.    for (n = 0; dir && strcmp(dir->dir.name, "F1_END"); n++)
  932.       dir = dir->next;
  933.    NumFTexture = n;
  934.    /* get the actual names from master dir. */
  935.    dir = FindMasterDir( MasterDir, "F1_START");
  936.    dir = dir->next;
  937.    FTexture = GetMemory( NumFTexture * sizeof( char *));
  938.    for (n = 0; n < NumFTexture; n++)
  939.    {
  940.       FTexture[ n] = GetMemory( 9 * sizeof( char));
  941.       strncpy( FTexture[ n], dir->dir.name, 8);
  942.       FTexture[ n][ 8] = '\0';
  943.       dir = dir->next;
  944.    }
  945.    if (Registered)
  946.    {
  947.       /* count the names */
  948.       dir = FindMasterDir( MasterDir, "F2_START");
  949.       dir = dir->next;
  950.       for (n = 0; dir && strcmp(dir->dir.name, "F2_END"); n++)
  951.      dir = dir->next;
  952.       /* get the actual names from master dir. */
  953.       dir = FindMasterDir( MasterDir, "F2_START");
  954.       dir = dir->next;
  955.       FTexture = ResizeMemory( FTexture, (NumFTexture + n) * sizeof( char *));
  956.       for (m = NumFTexture; m < NumFTexture + n; m++)
  957.       {
  958.      FTexture[ m] = GetMemory( 9 * sizeof( char));
  959.      strncpy( FTexture[ m], dir->dir.name, 8);
  960.      FTexture[ m][ 8] = '\0';
  961.      dir = dir->next;
  962.       }
  963.       NumFTexture += n;
  964.    }
  965.    /* sort the names */
  966.    qsort( FTexture, NumFTexture, sizeof( char *), SortTextures);
  967. }
  968.  
  969.  
  970.  
  971. /*
  972.    forget the floor/ceiling texture names
  973. */
  974.  
  975. void ForgetFTextureNames()
  976. {
  977.    int n;
  978.  
  979.    /* forget all names */
  980.    for (n = 0; n < NumFTexture; n++)
  981.       free( FTexture[ n]);
  982.  
  983.    /* forget the array */
  984.    NumFTexture = 0;
  985.    free( FTexture);
  986. }
  987.  
  988.  
  989.  
  990. /* end of file */
  991.