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