1 files changed, 1688 insertions, 0 deletions

diff --git a/src/p_setup.c b/src/p_setup.c
new file mode 100644
index 0000000..5247cb9
--- /dev/null
+++ b/src/p_setup.c
@@ -0,0 +1,1688 @@
+/* Emacs style mode select   -*- C++ -*-
+ *-----------------------------------------------------------------------------
+ *
+ *
+ *  PrBoom: a Doom port merged with LxDoom and LSDLDoom
+ *  based on BOOM, a modified and improved DOOM engine
+ *  Copyright (C) 1999 by
+ *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
+ *  Copyright (C) 1999-2000 by
+ *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
+ *  Copyright 2005, 2006 by
+ *  Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ *  02111-1307, USA.
+ *
+ * DESCRIPTION:
+ *  Do all the WAD I/O, get map description,
+ *  set up initial state and misc. LUTs.
+ *
+ *-----------------------------------------------------------------------------*/
+
+#include <math.h>
+
+#include "doomstat.h"
+#include "m_bbox.h"
+#include "m_argv.h"
+#include "g_game.h"
+#include "w_wad.h"
+#include "r_main.h"
+#include "r_things.h"
+#include "p_maputl.h"
+#include "p_map.h"
+#include "p_setup.h"
+#include "p_spec.h"
+#include "p_tick.h"
+#include "p_enemy.h"
+#include "s_sound.h"
+#include "lprintf.h" //jff 10/6/98 for debug outputs
+#include "v_video.h"
+#include "r_demo.h"
+#include "r_fps.h"
+
+//
+// MAP related Lookup tables.
+// Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
+//
+
+int      numvertexes;
+vertex_t *vertexes;
+
+int      numsegs;
+seg_t    *segs;
+
+int      numsectors;
+sector_t *sectors;
+
+int      numsubsectors;
+subsector_t *subsectors;
+
+int      numnodes;
+node_t   *nodes;
+
+int      numlines;
+line_t   *lines;
+
+int      numsides;
+side_t   *sides;
+
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// figgi 08/21/00 -- constants and globals for glBsp support
+#define gNd2            0x32644E67  // figgi -- suppport for new GL_VERT format v2.0
+#define gNd3            0x33644E67
+#define gNd4            0x34644E67
+#define gNd5            0x35644E67
+#define ZNOD            0x444F4E5A
+#define ZGLN            0x4E4C475A
+#define GL_VERT_OFFSET  4
+
+int     firstglvertex = 0;
+int     nodesVersion  = 0;
+boolean forceOldBsp   = false;
+
+// figgi 08/21/00 -- glSegs
+typedef struct
+{
+  unsigned short  v1;    // start vertex    (16 bit)
+  unsigned short  v2;    // end vertex      (16 bit)
+  unsigned short  linedef; // linedef, or -1 for minisegs
+  short     side;  // side on linedef: 0 for right, 1 for left
+  unsigned short  partner; // corresponding partner seg, or -1 on one-sided walls
+} glseg_t;
+
+// fixed 32 bit gl_vert format v2.0+ (glBsp 1.91)
+typedef struct
+{
+  fixed_t x,y;
+} mapglvertex_t;
+
+enum
+{
+   ML_GL_LABEL=0,  // A separator name, GL_ExMx or GL_MAPxx
+   ML_GL_VERTS,     // Extra Vertices
+   ML_GL_SEGS,     // Segs, from linedefs & minisegs
+   ML_GL_SSECT,    // SubSectors, list of segs
+   ML_GL_NODES     // GL BSP nodes
+};
+////////////////////////////////////////////////////////////////////////////////////////////
+
+
+// BLOCKMAP
+// Created from axis aligned bounding box
+// of the map, a rectangular array of
+// blocks of size ...
+// Used to speed up collision detection
+// by spatial subdivision in 2D.
+//
+// Blockmap size.
+
+int       bmapwidth, bmapheight;  // size in mapblocks
+
+// killough 3/1/98: remove blockmap limit internally:
+long      *blockmap;              // was short -- killough
+
+// offsets in blockmap are from here
+long      *blockmaplump;          // was short -- killough
+
+fixed_t   bmaporgx, bmaporgy;     // origin of block map
+
+mobj_t    **blocklinks;           // for thing chains
+
+//
+// REJECT
+// For fast sight rejection.
+// Speeds up enemy AI by skipping detailed
+//  LineOf Sight calculation.
+// Without the special effect, this could
+// be used as a PVS lookup as well.
+//
+
+static int rejectlump = -1;// cph - store reject lump num if cached
+const byte *rejectmatrix; // cph - const*
+
+// Maintain single and multi player starting spots.
+
+// 1/11/98 killough: Remove limit on deathmatch starts
+mapthing_t *deathmatchstarts;      // killough
+size_t     num_deathmatchstarts;   // killough
+
+mapthing_t *deathmatch_p;
+mapthing_t playerstarts[MAXPLAYERS];
+
+//
+// P_CheckForZDoomNodes
+//
+
+static boolean P_CheckForZDoomNodes(int lumpnum, int gl_lumpnum)
+{
+  const void *data;
+
+  data = W_CacheLumpNum(lumpnum + ML_NODES);
+  if (*(const int *)data == ZNOD)
+    I_Error("P_CheckForZDoomNodes: ZDoom nodes not supported yet");
+
+  data = W_CacheLumpNum(lumpnum + ML_SSECTORS);
+  if (*(const int *)data == ZGLN)
+    I_Error("P_CheckForZDoomNodes: ZDoom GL nodes not supported yet");
+
+  return false;
+}
+
+//
+// P_GetNodesVersion
+//
+
+static void P_GetNodesVersion(int lumpnum, int gl_lumpnum)
+{
+  const void *data;
+
+  data = W_CacheLumpNum(gl_lumpnum+ML_GL_VERTS);
+  if ( (gl_lumpnum > lumpnum) && (forceOldBsp == false) && (compatibility_level >= prboom_2_compatibility) ) {
+    if (*(const int *)data == gNd2) {
+      data = W_CacheLumpNum(gl_lumpnum+ML_GL_SEGS);
+      if (*(const int *)data == gNd3) {
+        nodesVersion = gNd3;
+        lprintf(LO_DEBUG, "P_GetNodesVersion: found version 3 nodes\n");
+        I_Error("P_GetNodesVersion: version 3 nodes not supported\n");
+      } else {
+        nodesVersion = gNd2;
+        lprintf(LO_DEBUG, "P_GetNodesVersion: found version 2 nodes\n");
+      }
+    }
+    if (*(const int *)data == gNd4) {
+      nodesVersion = gNd4;
+      lprintf(LO_DEBUG, "P_GetNodesVersion: found version 4 nodes\n");
+      I_Error("P_GetNodesVersion: version 4 nodes not supported\n");
+    }
+    if (*(const int *)data == gNd5) {
+      nodesVersion = gNd5;
+      lprintf(LO_DEBUG, "P_GetNodesVersion: found version 5 nodes\n");
+      I_Error("P_GetNodesVersion: version 5 nodes not supported\n");
+    }
+  } else {
+    nodesVersion = 0;
+    lprintf(LO_DEBUG,"P_GetNodesVersion: using normal BSP nodes\n");
+    if (P_CheckForZDoomNodes(lumpnum, gl_lumpnum))
+      I_Error("P_GetNodesVersion: ZDoom nodes not supported yet");
+  }
+}
+
+//
+// P_LoadVertexes
+//
+// killough 5/3/98: reformatted, cleaned up
+//
+static void P_LoadVertexes (int lump)
+{
+  const mapvertex_t *data; // cph - const
+  int i;
+
+  // Determine number of lumps:
+  //  total lump length / vertex record length.
+  numvertexes = W_LumpLength(lump) / sizeof(mapvertex_t);
+
+  // Allocate zone memory for buffer.
+  vertexes = Z_Malloc(numvertexes*sizeof(vertex_t),PU_LEVEL,0);
+
+  // Load data into cache.
+  // cph 2006/07/29 - cast to mapvertex_t here, making the loop below much neater
+  data = (const mapvertex_t *)W_CacheLumpNum(lump);
+
+  // Copy and convert vertex coordinates,
+  // internal representation as fixed.
+  for (i=0; i<numvertexes; i++)
+    {
+      vertexes[i].x = SHORT(data[i].x)<<FRACBITS;
+      vertexes[i].y = SHORT(data[i].y)<<FRACBITS;
+    }
+
+  // Free buffer memory.
+  W_UnlockLumpNum(lump);
+}
+
+/*******************************************
+ * Name     : P_LoadVertexes2        *
+ * modified : 09/18/00, adapted for PrBoom *
+ * author   : figgi              *
+ * what   : support for gl nodes       *
+ *******************************************/
+
+// figgi -- FIXME: Automap showes wrong zoom boundaries when starting game
+//           when P_LoadVertexes2 is used with classic BSP nodes.
+
+static void P_LoadVertexes2(int lump, int gllump)
+{
+  const byte         *gldata;
+  int                 i;
+  const mapvertex_t*  ml;
+
+  firstglvertex = W_LumpLength(lump) / sizeof(mapvertex_t);
+  numvertexes   = W_LumpLength(lump) / sizeof(mapvertex_t);
+
+  if (gllump >= 0)  // check for glVertices
+  {
+    gldata = W_CacheLumpNum(gllump);
+
+    if (nodesVersion == gNd2) // 32 bit GL_VERT format (16.16 fixed)
+    {
+      const mapglvertex_t*  mgl;
+
+      numvertexes += (W_LumpLength(gllump) - GL_VERT_OFFSET)/sizeof(mapglvertex_t);
+      vertexes   = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0);
+      mgl      = (const mapglvertex_t *) (gldata + GL_VERT_OFFSET);
+
+      for (i = firstglvertex; i < numvertexes; i++)
+      {
+        vertexes[i].x = mgl->x;
+        vertexes[i].y = mgl->y;
+        mgl++;
+      }
+    }
+    else
+    {
+      numvertexes += W_LumpLength(gllump)/sizeof(mapvertex_t);
+      vertexes     = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0);
+      ml       = (const mapvertex_t *)gldata;
+
+      for (i = firstglvertex; i < numvertexes; i++)
+      {
+        vertexes[i].x = SHORT(ml->x)<<FRACBITS;
+        vertexes[i].y = SHORT(ml->y)<<FRACBITS;
+        ml++;
+      }
+    }
+    W_UnlockLumpNum(gllump);
+  }
+
+  ml = (const mapvertex_t*) W_CacheLumpNum(lump);
+
+  for (i=0; i < firstglvertex; i++)
+  {
+    vertexes[i].x = SHORT(ml->x)<<FRACBITS;
+    vertexes[i].y = SHORT(ml->y)<<FRACBITS;
+    ml++;
+  }
+  W_UnlockLumpNum(lump);
+}
+
+
+/*******************************************
+ * created  : 08/13/00             *
+ * modified : 09/18/00, adapted for PrBoom *
+ * author   : figgi              *
+ * what   : basic functions needed for   *
+ *            computing  gl nodes      *
+ *******************************************/
+
+static int checkGLVertex(int num)
+{
+  if (num & 0x8000)
+    num = (num&0x7FFF)+firstglvertex;
+  return num;
+}
+
+
+static float GetDistance(int dx, int dy)
+{
+  float fx = (float)(dx)/FRACUNIT, fy = (float)(dy)/FRACUNIT;
+  return (float)sqrt(fx*fx + fy*fy);
+}
+
+
+static int GetOffset(vertex_t *v1, vertex_t *v2)
+{
+  float a, b;
+  int r;
+  a = (float)(v1->x - v2->x) / (float)FRACUNIT;
+  b = (float)(v1->y - v2->y) / (float)FRACUNIT;
+  r = (int)(sqrt(a*a+b*b) * (float)FRACUNIT);
+  return r;
+}
+
+
+
+//
+// P_LoadSegs
+//
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadSegs (int lump)
+{
+  int  i;
+  const mapseg_t *data; // cph - const
+
+  numsegs = W_LumpLength(lump) / sizeof(mapseg_t);
+  segs = Z_Calloc(numsegs,sizeof(seg_t),PU_LEVEL,0);
+  data = (const mapseg_t *)W_CacheLumpNum(lump); // cph - wad lump handling updated
+
+  if ((!data) || (!numsegs))
+    I_Error("P_LoadSegs: no segs in level");
+
+  for (i=0; i<numsegs; i++)
+    {
+      seg_t *li = segs+i;
+      const mapseg_t *ml = data + i;
+      unsigned short v1, v2;
+
+      int side, linedef;
+      line_t *ldef;
+
+      li->iSegID = i; // proff 11/05/2000: needed for OpenGL
+
+      v1 = (unsigned short)SHORT(ml->v1);
+      v2 = (unsigned short)SHORT(ml->v2);
+      li->v1 = &vertexes[v1];
+      li->v2 = &vertexes[v2];
+
+      li->miniseg = false; // figgi -- there are no minisegs in classic BSP nodes
+      li->length  = GetDistance(li->v2->x - li->v1->x, li->v2->y - li->v1->y);
+      li->angle = (SHORT(ml->angle))<<16;
+      li->offset =(SHORT(ml->offset))<<16;
+      linedef = (unsigned short)SHORT(ml->linedef);
+      ldef = &lines[linedef];
+      li->linedef = ldef;
+      side = SHORT(ml->side);
+      li->sidedef = &sides[ldef->sidenum[side]];
+
+      /* cph 2006/09/30 - our frontsector can be the second side of the
+       * linedef, so must check for NO_INDEX in case we are incorrectly
+       * referencing the back of a 1S line */
+      if (ldef->sidenum[side] != NO_INDEX)
+        li->frontsector = sides[ldef->sidenum[side]].sector;
+      else {
+        li->frontsector = 0;
+        lprintf(LO_WARN, "P_LoadSegs: front of seg %i has no sidedef\n", i);
+      }
+
+      if (ldef->flags & ML_TWOSIDED && ldef->sidenum[side^1]!=NO_INDEX)
+        li->backsector = sides[ldef->sidenum[side^1]].sector;
+      else
+        li->backsector = 0;
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the data
+}
+
+
+
+/*******************************************
+ * Name     : P_LoadGLSegs           *
+ * created  : 08/13/00             *
+ * modified : 09/18/00, adapted for PrBoom *
+ * author   : figgi              *
+ * what   : support for gl nodes       *
+ *******************************************/
+static void P_LoadGLSegs(int lump)
+{
+  int     i;
+  const glseg_t   *ml;
+  line_t    *ldef;
+
+  numsegs = W_LumpLength(lump) / sizeof(glseg_t);
+  segs = Z_Malloc(numsegs * sizeof(seg_t), PU_LEVEL, 0);
+  memset(segs, 0, numsegs * sizeof(seg_t));
+  ml = (const glseg_t*)W_CacheLumpNum(lump);
+
+  if ((!ml) || (!numsegs))
+    I_Error("P_LoadGLSegs: no glsegs in level");
+
+  for(i = 0; i < numsegs; i++)
+  {             // check for gl-vertices
+    segs[i].v1 = &vertexes[checkGLVertex(SHORT(ml->v1))];
+    segs[i].v2 = &vertexes[checkGLVertex(SHORT(ml->v2))];
+    segs[i].iSegID  = i;
+
+    if(ml->linedef != (unsigned short)-1) // skip minisegs
+    {
+      ldef = &lines[ml->linedef];
+      segs[i].linedef = ldef;
+      segs[i].miniseg = false;
+      segs[i].angle = R_PointToAngle2(segs[i].v1->x,segs[i].v1->y,segs[i].v2->x,segs[i].v2->y);
+
+      segs[i].sidedef = &sides[ldef->sidenum[ml->side]];
+      segs[i].length  = GetDistance(segs[i].v2->x - segs[i].v1->x, segs[i].v2->y - segs[i].v1->y);
+      segs[i].frontsector = sides[ldef->sidenum[ml->side]].sector;
+      if (ldef->flags & ML_TWOSIDED)
+        segs[i].backsector = sides[ldef->sidenum[ml->side^1]].sector;
+      else
+        segs[i].backsector = 0;
+
+      if (ml->side)
+        segs[i].offset = GetOffset(segs[i].v1, ldef->v2);
+      else
+        segs[i].offset = GetOffset(segs[i].v1, ldef->v1);
+    }
+    else
+    {
+      segs[i].miniseg = true;
+      segs[i].angle  = 0;
+      segs[i].offset  = 0;
+      segs[i].length  = 0;
+      segs[i].linedef = NULL;
+      segs[i].sidedef = NULL;
+      segs[i].frontsector = NULL;
+      segs[i].backsector  = NULL;
+    }
+    ml++;
+  }
+  W_UnlockLumpNum(lump);
+}
+
+//
+// P_LoadSubsectors
+//
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadSubsectors (int lump)
+{
+  /* cph 2006/07/29 - make data a const mapsubsector_t *, so the loop below is simpler & gives no constness warnings */
+  const mapsubsector_t *data;
+  int  i;
+
+  numsubsectors = W_LumpLength (lump) / sizeof(mapsubsector_t);
+  subsectors = Z_Calloc(numsubsectors,sizeof(subsector_t),PU_LEVEL,0);
+  data = (const mapsubsector_t *)W_CacheLumpNum(lump);
+
+  if ((!data) || (!numsubsectors))
+    I_Error("P_LoadSubsectors: no subsectors in level");
+
+  for (i=0; i<numsubsectors; i++)
+  {
+    subsectors[i].numlines  = (unsigned short)SHORT(data[i].numsegs );
+    subsectors[i].firstline = (unsigned short)SHORT(data[i].firstseg);
+  }
+
+  W_UnlockLumpNum(lump); // cph - release the data
+}
+
+//
+// P_LoadSectors
+//
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadSectors (int lump)
+{
+  const byte *data; // cph - const*
+  int  i;
+
+  numsectors = W_LumpLength (lump) / sizeof(mapsector_t);
+  sectors = Z_Calloc (numsectors,sizeof(sector_t),PU_LEVEL,0);
+  data = W_CacheLumpNum (lump); // cph - wad lump handling updated
+
+  for (i=0; i<numsectors; i++)
+    {
+      sector_t *ss = sectors + i;
+      const mapsector_t *ms = (const mapsector_t *) data + i;
+
+      ss->iSectorID=i; // proff 04/05/2000: needed for OpenGL
+      ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
+      ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
+      ss->floorpic = R_FlatNumForName(ms->floorpic);
+      ss->ceilingpic = R_FlatNumForName(ms->ceilingpic);
+      ss->lightlevel = SHORT(ms->lightlevel);
+      ss->special = SHORT(ms->special);
+      ss->oldspecial = SHORT(ms->special);
+      ss->tag = SHORT(ms->tag);
+      ss->thinglist = NULL;
+      ss->touching_thinglist = NULL;            // phares 3/14/98
+
+      ss->nextsec = -1; //jff 2/26/98 add fields to support locking out
+      ss->prevsec = -1; // stair retriggering until build completes
+
+      // killough 3/7/98:
+      ss->floor_xoffs = 0;
+      ss->floor_yoffs = 0;      // floor and ceiling flats offsets
+      ss->ceiling_xoffs = 0;
+      ss->ceiling_yoffs = 0;
+      ss->heightsec = -1;       // sector used to get floor and ceiling height
+      ss->floorlightsec = -1;   // sector used to get floor lighting
+      // killough 3/7/98: end changes
+
+      // killough 4/11/98 sector used to get ceiling lighting:
+      ss->ceilinglightsec = -1;
+
+      // killough 4/4/98: colormaps:
+      ss->bottommap = ss->midmap = ss->topmap = 0;
+
+      // killough 10/98: sky textures coming from sidedefs:
+      ss->sky = 0;
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the data
+}
+
+
+//
+// P_LoadNodes
+//
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadNodes (int lump)
+{
+  const byte *data; // cph - const*
+  int  i;
+
+  numnodes = W_LumpLength (lump) / sizeof(mapnode_t);
+  nodes = Z_Malloc (numnodes*sizeof(node_t),PU_LEVEL,0);
+  data = W_CacheLumpNum (lump); // cph - wad lump handling updated
+
+  if ((!data) || (!numnodes))
+  {
+    // allow trivial maps
+    if (numsubsectors == 1)
+      lprintf(LO_INFO,
+          "P_LoadNodes: trivial map (no nodes, one subsector)\n");
+    else
+      I_Error("P_LoadNodes: no nodes in level");
+  }
+
+  for (i=0; i<numnodes; i++)
+    {
+      node_t *no = nodes + i;
+      const mapnode_t *mn = (const mapnode_t *) data + i;
+      int j;
+
+      no->x = SHORT(mn->x)<<FRACBITS;
+      no->y = SHORT(mn->y)<<FRACBITS;
+      no->dx = SHORT(mn->dx)<<FRACBITS;
+      no->dy = SHORT(mn->dy)<<FRACBITS;
+
+      for (j=0 ; j<2 ; j++)
+        {
+          int k;
+          no->children[j] = SHORT(mn->children[j]);
+          for (k=0 ; k<4 ; k++)
+            no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
+        }
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the data
+}
+
+
+/*
+ * P_LoadThings
+ *
+ * killough 5/3/98: reformatted, cleaned up
+ * cph 2001/07/07 - don't write into the lump cache, especially non-idepotent
+ * changes like byte order reversals. Take a copy to edit.
+ */
+
+static void P_LoadThings (int lump)
+{
+  int  i, numthings = W_LumpLength (lump) / sizeof(mapthing_t);
+  const mapthing_t *data = W_CacheLumpNum (lump);
+
+  if ((!data) || (!numthings))
+    I_Error("P_LoadThings: no things in level");
+
+  for (i=0; i<numthings; i++)
+    {
+      mapthing_t mt = data[i];
+
+      mt.x = SHORT(mt.x);
+      mt.y = SHORT(mt.y);
+      mt.angle = SHORT(mt.angle);
+      mt.type = SHORT(mt.type);
+      mt.options = SHORT(mt.options);
+
+      if (!P_IsDoomnumAllowed(mt.type))
+        continue;
+
+      // Do spawn all other stuff.
+      P_SpawnMapThing(&mt);
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the data
+}
+
+//
+// P_LoadLineDefs
+// Also counts secret lines for intermissions.
+//        ^^^
+// ??? killough ???
+// Does this mean secrets used to be linedef-based, rather than sector-based?
+//
+// killough 4/4/98: split into two functions, to allow sidedef overloading
+//
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadLineDefs (int lump)
+{
+  const byte *data; // cph - const*
+  int  i;
+
+  numlines = W_LumpLength (lump) / sizeof(maplinedef_t);
+  lines = Z_Calloc (numlines,sizeof(line_t),PU_LEVEL,0);
+  data = W_CacheLumpNum (lump); // cph - wad lump handling updated
+
+  for (i=0; i<numlines; i++)
+    {
+      const maplinedef_t *mld = (const maplinedef_t *) data + i;
+      line_t *ld = lines+i;
+      vertex_t *v1, *v2;
+
+      ld->flags = (unsigned short)SHORT(mld->flags);
+      ld->special = SHORT(mld->special);
+      ld->tag = SHORT(mld->tag);
+      v1 = ld->v1 = &vertexes[(unsigned short)SHORT(mld->v1)];
+      v2 = ld->v2 = &vertexes[(unsigned short)SHORT(mld->v2)];
+      ld->dx = v2->x - v1->x;
+      ld->dy = v2->y - v1->y;
+
+      ld->tranlump = -1;   // killough 4/11/98: no translucency by default
+
+      ld->slopetype = !ld->dx ? ST_VERTICAL : !ld->dy ? ST_HORIZONTAL :
+        FixedDiv(ld->dy, ld->dx) > 0 ? ST_POSITIVE : ST_NEGATIVE;
+
+      if (v1->x < v2->x)
+        {
+          ld->bbox[BOXLEFT] = v1->x;
+          ld->bbox[BOXRIGHT] = v2->x;
+        }
+      else
+        {
+          ld->bbox[BOXLEFT] = v2->x;
+          ld->bbox[BOXRIGHT] = v1->x;
+        }
+      if (v1->y < v2->y)
+        {
+          ld->bbox[BOXBOTTOM] = v1->y;
+          ld->bbox[BOXTOP] = v2->y;
+        }
+      else
+        {
+          ld->bbox[BOXBOTTOM] = v2->y;
+          ld->bbox[BOXTOP] = v1->y;
+        }
+
+      /* calculate sound origin of line to be its midpoint */
+      //e6y: fix sound origin for large levels
+      // no need for comp_sound test, these are only used when comp_sound = 0
+      ld->soundorg.x = ld->bbox[BOXLEFT] / 2 + ld->bbox[BOXRIGHT] / 2;
+      ld->soundorg.y = ld->bbox[BOXTOP] / 2 + ld->bbox[BOXBOTTOM] / 2;
+
+      ld->iLineID=i; // proff 04/05/2000: needed for OpenGL
+      ld->sidenum[0] = SHORT(mld->sidenum[0]);
+      ld->sidenum[1] = SHORT(mld->sidenum[1]);
+
+      { 
+        /* cph 2006/09/30 - fix sidedef errors right away.
+         * cph 2002/07/20 - these errors are fatal if not fixed, so apply them
+         * in compatibility mode - a desync is better than a crash! */
+        int j;
+        
+        for (j=0; j < 2; j++)
+        {
+          if (ld->sidenum[j] != NO_INDEX && ld->sidenum[j] >= numsides) {
+            ld->sidenum[j] = NO_INDEX;
+            lprintf(LO_WARN, "P_LoadLineDefs: linedef %d has out-of-range sidedef number\n",numlines-i-1);
+          }
+        }
+        
+        // killough 11/98: fix common wad errors (missing sidedefs):
+        
+        if (ld->sidenum[0] == NO_INDEX) {
+          ld->sidenum[0] = 0;  // Substitute dummy sidedef for missing right side
+          // cph - print a warning about the bug
+          lprintf(LO_WARN, "P_LoadLineDefs: linedef %d missing first sidedef\n",numlines-i-1);
+        }
+        
+        if ((ld->sidenum[1] == NO_INDEX) && (ld->flags & ML_TWOSIDED)) {
+          ld->flags &= ~ML_TWOSIDED;  // Clear 2s flag for missing left side
+          // cph - print a warning about the bug
+          lprintf(LO_WARN, "P_LoadLineDefs: linedef %d has two-sided flag set, but no second sidedef\n",numlines-i-1);
+        }
+      }
+
+      // killough 4/4/98: support special sidedef interpretation below
+      if (ld->sidenum[0] != NO_INDEX && ld->special)
+        sides[*ld->sidenum].special = ld->special;
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the lump
+}
+
+// killough 4/4/98: delay using sidedefs until they are loaded
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadLineDefs2(int lump)
+{
+  int i = numlines;
+  register line_t *ld = lines;
+  for (;i--;ld++)
+    {
+      ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be NO_INDEX here
+      ld->backsector  = ld->sidenum[1]!=NO_INDEX ? sides[ld->sidenum[1]].sector : 0;
+      switch (ld->special)
+        {                       // killough 4/11/98: handle special types
+          int lump, j;
+
+        case 260:               // killough 4/11/98: translucent 2s textures
+            lump = sides[*ld->sidenum].special; // translucency from sidedef
+            if (!ld->tag)                       // if tag==0,
+              ld->tranlump = lump;              // affect this linedef only
+            else
+              for (j=0;j<numlines;j++)          // if tag!=0,
+                if (lines[j].tag == ld->tag)    // affect all matching linedefs
+                  lines[j].tranlump = lump;
+            break;
+        }
+    }
+}
+
+//
+// P_LoadSideDefs
+//
+// killough 4/4/98: split into two functions
+
+static void P_LoadSideDefs (int lump)
+{
+  numsides = W_LumpLength(lump) / sizeof(mapsidedef_t);
+  sides = Z_Calloc(numsides,sizeof(side_t),PU_LEVEL,0);
+}
+
+// killough 4/4/98: delay using texture names until
+// after linedefs are loaded, to allow overloading.
+// killough 5/3/98: reformatted, cleaned up
+
+static void P_LoadSideDefs2(int lump)
+{
+  const byte *data = W_CacheLumpNum(lump); // cph - const*, wad lump handling updated
+  int  i;
+
+  for (i=0; i<numsides; i++)
+    {
+      register const mapsidedef_t *msd = (const mapsidedef_t *) data + i;
+      register side_t *sd = sides + i;
+      register sector_t *sec;
+
+      sd->textureoffset = SHORT(msd->textureoffset)<<FRACBITS;
+      sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
+
+      { /* cph 2006/09/30 - catch out-of-range sector numbers; use sector 0 instead */
+        unsigned short sector_num = SHORT(msd->sector);
+        if (sector_num >= numsectors) {
+          lprintf(LO_WARN,"P_LoadSideDefs2: sidedef %i has out-of-range sector num %u\n", i, sector_num);
+          sector_num = 0;
+        }
+        sd->sector = sec = &sectors[sector_num];
+      }
+
+      // killough 4/4/98: allow sidedef texture names to be overloaded
+      // killough 4/11/98: refined to allow colormaps to work as wall
+      // textures if invalid as colormaps but valid as textures.
+      switch (sd->special)
+        {
+        case 242:                       // variable colormap via 242 linedef
+          sd->bottomtexture =
+            (sec->bottommap =   R_ColormapNumForName(msd->bottomtexture)) < 0 ?
+            sec->bottommap = 0, R_TextureNumForName(msd->bottomtexture): 0 ;
+          sd->midtexture =
+            (sec->midmap =   R_ColormapNumForName(msd->midtexture)) < 0 ?
+            sec->midmap = 0, R_TextureNumForName(msd->midtexture)  : 0 ;
+          sd->toptexture =
+            (sec->topmap =   R_ColormapNumForName(msd->toptexture)) < 0 ?
+            sec->topmap = 0, R_TextureNumForName(msd->toptexture)  : 0 ;
+          break;
+
+        case 260: // killough 4/11/98: apply translucency to 2s normal texture
+          sd->midtexture = strncasecmp("TRANMAP", msd->midtexture, 8) ?
+            (sd->special = W_CheckNumForName(msd->midtexture)) < 0 ||
+            W_LumpLength(sd->special) != 65536 ?
+            sd->special=0, R_TextureNumForName(msd->midtexture) :
+              (sd->special++, 0) : (sd->special=0);
+          sd->toptexture = R_TextureNumForName(msd->toptexture);
+          sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
+          break;
+
+        default:                        // normal cases
+          sd->midtexture = R_SafeTextureNumForName(msd->midtexture, i);
+          sd->toptexture = R_SafeTextureNumForName(msd->toptexture, i);
+          sd->bottomtexture = R_SafeTextureNumForName(msd->bottomtexture, i);
+          break;
+        }
+    }
+
+  W_UnlockLumpNum(lump); // cph - release the lump
+}
+
+//
+// jff 10/6/98
+// New code added to speed up calculation of internal blockmap
+// Algorithm is order of nlines*(ncols+nrows) not nlines*ncols*nrows
+//
+
+#define blkshift 7               /* places to shift rel position for cell num */
+#define blkmask ((1<<blkshift)-1)/* mask for rel position within cell */
+#define blkmargin 0              /* size guardband around map used */
+                                 // jff 10/8/98 use guardband>0
+                                 // jff 10/12/98 0 ok with + 1 in rows,cols
+
+typedef struct linelist_t        // type used to list lines in each block
+{
+  long num;
+  struct linelist_t *next;
+} linelist_t;
+
+//
+// Subroutine to add a line number to a block list
+// It simply returns if the line is already in the block
+//
+
+static void AddBlockLine
+(
+  linelist_t **lists,
+  int *count,
+  int *done,
+  int blockno,
+  long lineno
+)
+{
+  linelist_t *l;
+
+  if (done[blockno])
+    return;
+
+  l = malloc(sizeof(linelist_t));
+  l->num = lineno;
+  l->next = lists[blockno];
+  lists[blockno] = l;
+  count[blockno]++;
+  done[blockno] = 1;
+}
+
+//
+// Actually construct the blockmap lump from the level data
+//
+// This finds the intersection of each linedef with the column and
+// row lines at the left and bottom of each blockmap cell. It then
+// adds the line to all block lists touching the intersection.
+//
+
+static void P_CreateBlockMap(void)
+{
+  int xorg,yorg;                 // blockmap origin (lower left)
+  int nrows,ncols;               // blockmap dimensions
+  linelist_t **blocklists=NULL;  // array of pointers to lists of lines
+  int *blockcount=NULL;          // array of counters of line lists
+  int *blockdone=NULL;           // array keeping track of blocks/line
+  int NBlocks;                   // number of cells = nrows*ncols
+  long linetotal=0;              // total length of all blocklists
+  int i,j;
+  int map_minx=INT_MAX;          // init for map limits search
+  int map_miny=INT_MAX;
+  int map_maxx=INT_MIN;
+  int map_maxy=INT_MIN;
+
+  // scan for map limits, which the blockmap must enclose
+
+  for (i=0;i<numvertexes;i++)
+  {
+    fixed_t t;
+
+    if ((t=vertexes[i].x) < map_minx)
+      map_minx = t;
+    else if (t > map_maxx)
+      map_maxx = t;
+    if ((t=vertexes[i].y) < map_miny)
+      map_miny = t;
+    else if (t > map_maxy)
+      map_maxy = t;
+  }
+  map_minx >>= FRACBITS;    // work in map coords, not fixed_t
+  map_maxx >>= FRACBITS;
+  map_miny >>= FRACBITS;
+  map_maxy >>= FRACBITS;
+
+  // set up blockmap area to enclose level plus margin
+
+  xorg = map_minx-blkmargin;
+  yorg = map_miny-blkmargin;
+  ncols = (map_maxx+blkmargin-xorg+1+blkmask)>>blkshift;  //jff 10/12/98
+  nrows = (map_maxy+blkmargin-yorg+1+blkmask)>>blkshift;  //+1 needed for
+  NBlocks = ncols*nrows;                                  //map exactly 1 cell
+
+  // create the array of pointers on NBlocks to blocklists
+  // also create an array of linelist counts on NBlocks
+  // finally make an array in which we can mark blocks done per line
+
+  // CPhipps - calloc's
+  blocklists = calloc(NBlocks,sizeof(linelist_t *));
+  blockcount = calloc(NBlocks,sizeof(int));
+  blockdone = malloc(NBlocks*sizeof(int));
+
+  // initialize each blocklist, and enter the trailing -1 in all blocklists
+  // note the linked list of lines grows backwards
+
+  for (i=0;i<NBlocks;i++)
+  {
+    blocklists[i] = malloc(sizeof(linelist_t));
+    blocklists[i]->num = -1;
+    blocklists[i]->next = NULL;
+    blockcount[i]++;
+  }
+
+  // For each linedef in the wad, determine all blockmap blocks it touches,
+  // and add the linedef number to the blocklists for those blocks
+
+  for (i=0;i<numlines;i++)
+  {
+    int x1 = lines[i].v1->x>>FRACBITS;         // lines[i] map coords
+    int y1 = lines[i].v1->y>>FRACBITS;
+    int x2 = lines[i].v2->x>>FRACBITS;
+    int y2 = lines[i].v2->y>>FRACBITS;
+    int dx = x2-x1;
+    int dy = y2-y1;
+    int vert = !dx;                            // lines[i] slopetype
+    int horiz = !dy;
+    int spos = (dx^dy) > 0;
+    int sneg = (dx^dy) < 0;
+    int bx,by;                                 // block cell coords
+    int minx = x1>x2? x2 : x1;                 // extremal lines[i] coords
+    int maxx = x1>x2? x1 : x2;
+    int miny = y1>y2? y2 : y1;
+    int maxy = y1>y2? y1 : y2;
+
+    // no blocks done for this linedef yet
+
+    memset(blockdone,0,NBlocks*sizeof(int));
+
+    // The line always belongs to the blocks containing its endpoints
+
+    bx = (x1-xorg)>>blkshift;
+    by = (y1-yorg)>>blkshift;
+    AddBlockLine(blocklists,blockcount,blockdone,by*ncols+bx,i);
+    bx = (x2-xorg)>>blkshift;
+    by = (y2-yorg)>>blkshift;
+    AddBlockLine(blocklists,blockcount,blockdone,by*ncols+bx,i);
+
+
+    // For each column, see where the line along its left edge, which
+    // it contains, intersects the Linedef i. Add i to each corresponding
+    // blocklist.
+
+    if (!vert)    // don't interesect vertical lines with columns
+    {
+      for (j=0;j<ncols;j++)
+      {
+        // intersection of Linedef with x=xorg+(j<<blkshift)
+        // (y-y1)*dx = dy*(x-x1)
+        // y = dy*(x-x1)+y1*dx;
+
+        int x = xorg+(j<<blkshift);       // (x,y) is intersection
+        int y = (dy*(x-x1))/dx+y1;
+        int yb = (y-yorg)>>blkshift;      // block row number
+        int yp = (y-yorg)&blkmask;        // y position within block
+
+        if (yb<0 || yb>nrows-1)     // outside blockmap, continue
+          continue;
+
+        if (x<minx || x>maxx)       // line doesn't touch column
+          continue;
+
+        // The cell that contains the intersection point is always added
+
+        AddBlockLine(blocklists,blockcount,blockdone,ncols*yb+j,i);
+
+        // if the intersection is at a corner it depends on the slope
+        // (and whether the line extends past the intersection) which
+        // blocks are hit
+
+        if (yp==0)        // intersection at a corner
+        {
+          if (sneg)       //   \ - blocks x,y-, x-,y
+          {
+            if (yb>0 && miny<y)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*(yb-1)+j,i);
+            if (j>0 && minx<x)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*yb+j-1,i);
+          }
+          else if (spos)  //   / - block x-,y-
+          {
+            if (yb>0 && j>0 && minx<x)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*(yb-1)+j-1,i);
+          }
+          else if (horiz) //   - - block x-,y
+          {
+            if (j>0 && minx<x)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*yb+j-1,i);
+          }
+        }
+        else if (j>0 && minx<x) // else not at corner: x-,y
+          AddBlockLine(blocklists,blockcount,blockdone,ncols*yb+j-1,i);
+      }
+    }
+
+    // For each row, see where the line along its bottom edge, which
+    // it contains, intersects the Linedef i. Add i to all the corresponding
+    // blocklists.
+
+    if (!horiz)
+    {
+      for (j=0;j<nrows;j++)
+      {
+        // intersection of Linedef with y=yorg+(j<<blkshift)
+        // (x,y) on Linedef i satisfies: (y-y1)*dx = dy*(x-x1)
+        // x = dx*(y-y1)/dy+x1;
+
+        int y = yorg+(j<<blkshift);       // (x,y) is intersection
+        int x = (dx*(y-y1))/dy+x1;
+        int xb = (x-xorg)>>blkshift;      // block column number
+        int xp = (x-xorg)&blkmask;        // x position within block
+
+        if (xb<0 || xb>ncols-1)   // outside blockmap, continue
+          continue;
+
+        if (y<miny || y>maxy)     // line doesn't touch row
+          continue;
+
+        // The cell that contains the intersection point is always added
+
+        AddBlockLine(blocklists,blockcount,blockdone,ncols*j+xb,i);
+
+        // if the intersection is at a corner it depends on the slope
+        // (and whether the line extends past the intersection) which
+        // blocks are hit
+
+        if (xp==0)        // intersection at a corner
+        {
+          if (sneg)       //   \ - blocks x,y-, x-,y
+          {
+            if (j>0 && miny<y)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*(j-1)+xb,i);
+            if (xb>0 && minx<x)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*j+xb-1,i);
+          }
+          else if (vert)  //   | - block x,y-
+          {
+            if (j>0 && miny<y)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*(j-1)+xb,i);
+          }
+          else if (spos)  //   / - block x-,y-
+          {
+            if (xb>0 && j>0 && miny<y)
+              AddBlockLine(blocklists,blockcount,blockdone,ncols*(j-1)+xb-1,i);
+          }
+        }
+        else if (j>0 && miny<y) // else not on a corner: x,y-
+          AddBlockLine(blocklists,blockcount,blockdone,ncols*(j-1)+xb,i);
+      }
+    }
+  }
+
+  // Add initial 0 to all blocklists
+  // count the total number of lines (and 0's and -1's)
+
+  memset(blockdone,0,NBlocks*sizeof(int));
+  for (i=0,linetotal=0;i<NBlocks;i++)
+  {
+    AddBlockLine(blocklists,blockcount,blockdone,i,0);
+    linetotal += blockcount[i];
+  }
+
+  // Create the blockmap lump
+
+  blockmaplump = Z_Malloc(sizeof(*blockmaplump) * (4+NBlocks+linetotal),
+                          PU_LEVEL, 0);
+  // blockmap header
+
+  blockmaplump[0] = bmaporgx = xorg << FRACBITS;
+  blockmaplump[1] = bmaporgy = yorg << FRACBITS;
+  blockmaplump[2] = bmapwidth  = ncols;
+  blockmaplump[3] = bmapheight = nrows;
+
+  // offsets to lists and block lists
+
+  for (i=0;i<NBlocks;i++)
+  {
+    linelist_t *bl = blocklists[i];
+    long offs = blockmaplump[4+i] =   // set offset to block's list
+      (i? blockmaplump[4+i-1] : 4+NBlocks) + (i? blockcount[i-1] : 0);
+
+    // add the lines in each block's list to the blockmaplump
+    // delete each list node as we go
+
+    while (bl)
+    {
+      linelist_t *tmp = bl->next;
+      blockmaplump[offs++] = bl->num;
+      free(bl);
+      bl = tmp;
+    }
+  }
+
+  // free all temporary storage
+
+  free (blocklists);
+  free (blockcount);
+  free (blockdone);
+}
+
+// jff 10/6/98
+// End new code added to speed up calculation of internal blockmap
+
+//
+// P_LoadBlockMap
+//
+// killough 3/1/98: substantially modified to work
+// towards removing blockmap limit (a wad limitation)
+//
+// killough 3/30/98: Rewritten to remove blockmap limit,
+// though current algorithm is brute-force and unoptimal.
+//
+
+static void P_LoadBlockMap (int lump)
+{
+  long count;
+
+  if (M_CheckParm("-blockmap") || W_LumpLength(lump)<8 || (count = W_LumpLength(lump)/2) >= 0x10000) //e6y
+    P_CreateBlockMap();
+  else
+    {
+      long i;
+      // cph - const*, wad lump handling updated
+      const short *wadblockmaplump = W_CacheLumpNum(lump);
+      blockmaplump = Z_Malloc(sizeof(*blockmaplump) * count, PU_LEVEL, 0);
+
+      // killough 3/1/98: Expand wad blockmap into larger internal one,
+      // by treating all offsets except -1 as unsigned and zero-extending
+      // them. This potentially doubles the size of blockmaps allowed,
+      // because Doom originally considered the offsets as always signed.
+
+      blockmaplump[0] = SHORT(wadblockmaplump[0]);
+      blockmaplump[1] = SHORT(wadblockmaplump[1]);
+      blockmaplump[2] = (long)(SHORT(wadblockmaplump[2])) & 0xffff;
+      blockmaplump[3] = (long)(SHORT(wadblockmaplump[3])) & 0xffff;
+
+      for (i=4 ; i<count ; i++)
+        {
+          short t = SHORT(wadblockmaplump[i]);          // killough 3/1/98
+          blockmaplump[i] = t == -1 ? -1l : (long) t & 0xffff;
+        }
+
+      W_UnlockLumpNum(lump); // cph - unlock the lump
+
+      bmaporgx = blockmaplump[0]<<FRACBITS;
+      bmaporgy = blockmaplump[1]<<FRACBITS;
+      bmapwidth = blockmaplump[2];
+      bmapheight = blockmaplump[3];
+    }
+
+  // clear out mobj chains - CPhipps - use calloc
+  blocklinks = Z_Calloc (bmapwidth*bmapheight,sizeof(*blocklinks),PU_LEVEL,0);
+  blockmap = blockmaplump+4;
+}
+
+//
+// P_LoadReject - load the reject table, padding it if it is too short
+// totallines must be the number returned by P_GroupLines()
+// an underflow will be padded with zeroes, or a doom.exe z_zone header
+// 
+// this function incorporates e6y's RejectOverrunAddInt code:
+// e6y: REJECT overrun emulation code
+// It's emulated successfully if the size of overflow no more than 16 bytes.
+// No more desync on teeth-32.wad\teeth-32.lmp.
+// http://www.doomworld.com/vb/showthread.php?s=&threadid=35214
+
+static void P_LoadReject(int lumpnum, int totallines)
+{
+  unsigned int length, required;
+  byte *newreject;
+
+  // dump any old cached reject lump, then cache the new one
+  if (rejectlump != -1)
+    W_UnlockLumpNum(rejectlump);
+  rejectlump = lumpnum + ML_REJECT;
+  rejectmatrix = W_CacheLumpNum(rejectlump);
+
+  required = (numsectors * numsectors + 7) / 8;
+  length = W_LumpLength(rejectlump);
+
+  if (length >= required)
+    return; // nothing to do
+
+  // allocate a new block and copy the reject table into it; zero the rest
+  // PU_LEVEL => will be freed on level exit
+  newreject = Z_Malloc(required, PU_LEVEL, NULL);
+  rejectmatrix = (const byte *)memmove(newreject, rejectmatrix, length);
+  memset(newreject + length, 0, required - length);
+  // unlock the original lump, it is no longer needed
+  W_UnlockLumpNum(rejectlump);
+  rejectlump = -1;
+
+  if (demo_compatibility)
+  {
+    // merged in RejectOverrunAddInt(), and the 4 calls to it, here
+    unsigned int rejectpad[4] = {
+      0,        // size, will be filled in using totallines
+      0,        // part of the header of a doom.exe z_zone block
+      50,       // DOOM_CONST_PU_LEVEL
+      0x1d4a11  // DOOM_CONST_ZONEID
+    };
+    unsigned int i, pad = 0, *src = rejectpad;
+    byte *dest = newreject + length;
+
+    rejectpad[0] = ((totallines*4+3)&~3)+24; // doom.exe zone header size
+
+    // copy at most 16 bytes from rejectpad
+    // emulating a 32-bit, little-endian architecture (can't memmove)
+    for (i = 0; i < required - length && i < 16; i++) { // 16 hard-coded
+      if (!(i&3)) // get the next 4 bytes to copy when i=0,4,8,12
+        pad = *src++;
+      *dest++ = pad & 0xff; // store lowest-significant byte
+      pad >>= 8; // rotate the next byte down
+    }
+  }
+  lprintf(LO_WARN, "P_LoadReject: REJECT too short (%u<%u) - padded\n",
+          length, required);
+}
+
+//
+// P_GroupLines
+// Builds sector line lists and subsector sector numbers.
+// Finds block bounding boxes for sectors.
+//
+// killough 5/3/98: reformatted, cleaned up
+// cph 18/8/99: rewritten to avoid O(numlines * numsectors) section
+// It makes things more complicated, but saves seconds on big levels
+// figgi 09/18/00 -- adapted for gl-nodes
+
+// cph - convenient sub-function
+static void P_AddLineToSector(line_t* li, sector_t* sector)
+{
+  fixed_t *bbox = (void*)sector->blockbox;
+
+  sector->lines[sector->linecount++] = li;
+  M_AddToBox (bbox, li->v1->x, li->v1->y);
+  M_AddToBox (bbox, li->v2->x, li->v2->y);
+}
+
+// modified to return totallines (needed by P_LoadReject)
+static int P_GroupLines (void)
+{
+  register line_t *li;
+  register sector_t *sector;
+  int i,j, total = numlines;
+
+  // figgi
+  for (i=0 ; i<numsubsectors ; i++)
+  {
+    seg_t *seg = &segs[subsectors[i].firstline];
+    subsectors[i].sector = NULL;
+    for(j=0; j<subsectors[i].numlines; j++)
+    {
+      if(seg->sidedef)
+      {
+        subsectors[i].sector = seg->sidedef->sector;
+        break;
+      }
+      seg++;
+    }
+    if(subsectors[i].sector == NULL)
+      I_Error("P_GroupLines: Subsector a part of no sector!\n");
+  }
+
+  // count number of lines in each sector
+  for (i=0,li=lines; i<numlines; i++, li++)
+    {
+      li->frontsector->linecount++;
+      if (li->backsector && li->backsector != li->frontsector)
+        {
+          li->backsector->linecount++;
+          total++;
+        }
+    }
+
+  {  // allocate line tables for each sector
+    line_t **linebuffer = Z_Malloc(total*sizeof(line_t *), PU_LEVEL, 0);
+
+    // e6y: REJECT overrun emulation code
+    // moved to P_LoadReject
+
+    for (i=0, sector = sectors; i<numsectors; i++, sector++)
+    {
+      sector->lines = linebuffer;
+      linebuffer += sector->linecount;
+      sector->linecount = 0;
+      M_ClearBox(sector->blockbox);
+    }
+  }
+
+  // Enter those lines
+  for (i=0,li=lines; i<numlines; i++, li++)
+  {
+    P_AddLineToSector(li, li->frontsector);
+    if (li->backsector && li->backsector != li->frontsector)
+      P_AddLineToSector(li, li->backsector);
+  }
+
+  for (i=0, sector = sectors; i<numsectors; i++, sector++)
+  {
+    fixed_t *bbox = (void*)sector->blockbox; // cph - For convenience, so
+                                  // I can sue the old code unchanged
+    int block;
+
+    // set the degenmobj_t to the middle of the bounding box
+    if (comp[comp_sound])
+    {
+      sector->soundorg.x = (bbox[BOXRIGHT]+bbox[BOXLEFT])/2;
+      sector->soundorg.y = (bbox[BOXTOP]+bbox[BOXBOTTOM])/2;
+    }
+    else
+    {
+      //e6y: fix sound origin for large levels
+      sector->soundorg.x = bbox[BOXRIGHT]/2+bbox[BOXLEFT]/2;
+      sector->soundorg.y = bbox[BOXTOP]/2+bbox[BOXBOTTOM]/2;
+    }
+
+    // adjust bounding box to map blocks
+    block = (bbox[BOXTOP]-bmaporgy+MAXRADIUS)>>MAPBLOCKSHIFT;
+    block = block >= bmapheight ? bmapheight-1 : block;
+    sector->blockbox[BOXTOP]=block;
+
+    block = (bbox[BOXBOTTOM]-bmaporgy-MAXRADIUS)>>MAPBLOCKSHIFT;
+    block = block < 0 ? 0 : block;
+    sector->blockbox[BOXBOTTOM]=block;
+
+    block = (bbox[BOXRIGHT]-bmaporgx+MAXRADIUS)>>MAPBLOCKSHIFT;
+    block = block >= bmapwidth ? bmapwidth-1 : block;
+    sector->blockbox[BOXRIGHT]=block;
+
+    block = (bbox[BOXLEFT]-bmaporgx-MAXRADIUS)>>MAPBLOCKSHIFT;
+    block = block < 0 ? 0 : block;
+    sector->blockbox[BOXLEFT]=block;
+  }
+
+  return total; // this value is needed by the reject overrun emulation code
+}
+
+//
+// killough 10/98
+//
+// Remove slime trails.
+//
+// Slime trails are inherent to Doom's coordinate system -- i.e. there is
+// nothing that a node builder can do to prevent slime trails ALL of the time,
+// because it's a product of the integer coodinate system, and just because
+// two lines pass through exact integer coordinates, doesn't necessarily mean
+// that they will intersect at integer coordinates. Thus we must allow for
+// fractional coordinates if we are to be able to split segs with node lines,
+// as a node builder must do when creating a BSP tree.
+//
+// A wad file does not allow fractional coordinates, so node builders are out
+// of luck except that they can try to limit the number of splits (they might
+// also be able to detect the degree of roundoff error and try to avoid splits
+// with a high degree of roundoff error). But we can use fractional coordinates
+// here, inside the engine. It's like the difference between square inches and
+// square miles, in terms of granularity.
+//
+// For each vertex of every seg, check to see whether it's also a vertex of
+// the linedef associated with the seg (i.e, it's an endpoint). If it's not
+// an endpoint, and it wasn't already moved, move the vertex towards the
+// linedef by projecting it using the law of cosines. Formula:
+//
+//      2        2                         2        2
+//    dx  x0 + dy  x1 + dx dy (y0 - y1)  dy  y0 + dx  y1 + dx dy (x0 - x1)
+//   {---------------------------------, ---------------------------------}
+//                  2     2                            2     2
+//                dx  + dy                           dx  + dy
+//
+// (x0,y0) is the vertex being moved, and (x1,y1)-(x1+dx,y1+dy) is the
+// reference linedef.
+//
+// Segs corresponding to orthogonal linedefs (exactly vertical or horizontal
+// linedefs), which comprise at least half of all linedefs in most wads, don't
+// need to be considered, because they almost never contribute to slime trails
+// (because then any roundoff error is parallel to the linedef, which doesn't
+// cause slime). Skipping simple orthogonal lines lets the code finish quicker.
+//
+// Please note: This section of code is not interchangable with TeamTNT's
+// code which attempts to fix the same problem.
+//
+// Firelines (TM) is a Rezistered Trademark of MBF Productions
+//
+
+static void P_RemoveSlimeTrails(void)         // killough 10/98
+{
+  byte *hit = calloc(1, numvertexes);         // Hitlist for vertices
+  int i;
+  for (i=0; i<numsegs; i++)                   // Go through each seg
+  {
+    const line_t *l;
+
+    if (segs[i].miniseg == true)        //figgi -- skip minisegs
+      return;
+
+    l = segs[i].linedef;            // The parent linedef
+    if (l->dx && l->dy)                     // We can ignore orthogonal lines
+    {
+    vertex_t *v = segs[i].v1;
+    do
+      if (!hit[v - vertexes])           // If we haven't processed vertex
+        {
+    hit[v - vertexes] = 1;        // Mark this vertex as processed
+    if (v != l->v1 && v != l->v2) // Exclude endpoints of linedefs
+      { // Project the vertex back onto the parent linedef
+        int_64_t dx2 = (l->dx >> FRACBITS) * (l->dx >> FRACBITS);
+        int_64_t dy2 = (l->dy >> FRACBITS) * (l->dy >> FRACBITS);
+        int_64_t dxy = (l->dx >> FRACBITS) * (l->dy >> FRACBITS);
+        int_64_t s = dx2 + dy2;
+        int x0 = v->x, y0 = v->y, x1 = l->v1->x, y1 = l->v1->y;
+        v->x = (int)((dx2 * x0 + dy2 * x1 + dxy * (y0 - y1)) / s);
+        v->y = (int)((dy2 * y0 + dx2 * y1 + dxy * (x0 - x1)) / s);
+      }
+        }  // Obsfucated C contest entry:   :)
+    while ((v != segs[i].v2) && (v = segs[i].v2));
+  }
+    }
+  free(hit);
+}
+
+//
+// P_SetupLevel
+//
+// killough 5/3/98: reformatted, cleaned up
+
+void P_SetupLevel(int episode, int map, int playermask, skill_t skill)
+{
+  int   i;
+  char  lumpname[9];
+  int   lumpnum;
+
+  char  gl_lumpname[9];
+  int   gl_lumpnum;
+
+  R_StopAllInterpolations();
+
+  totallive = totalkills = totalitems = totalsecret = wminfo.maxfrags = 0;
+  wminfo.partime = 180;
+
+  for (i=0; i<MAXPLAYERS; i++)
+    players[i].killcount = players[i].secretcount = players[i].itemcount = 0;
+
+  // Initial height of PointOfView will be set by player think.
+  players[consoleplayer].viewz = 1;
+
+  // Make sure all sounds are stopped before Z_FreeTags.
+  S_Start();
+
+  Z_FreeTags(PU_LEVEL, PU_PURGELEVEL-1);
+  if (rejectlump != -1) { // cph - unlock the reject table
+    W_UnlockLumpNum(rejectlump);
+    rejectlump = -1;
+  }
+
+#ifdef GL_DOOM
+// proff 11/99: clean the memory from textures etc.
+  gld_CleanMemory();
+#endif
+
+  P_InitThinkers();
+
+  // if working with a devlopment map, reload it
+  //    W_Reload ();     killough 1/31/98: W_Reload obsolete
+
+  // find map name
+  if (gamemode == commercial)
+  {
+    sprintf(lumpname, "map%02d", map);           // killough 1/24/98: simplify
+    sprintf(gl_lumpname, "gl_map%02d", map);    // figgi
+  }
+  else
+  {
+    sprintf(lumpname, "E%dM%d", episode, map);   // killough 1/24/98: simplify
+    sprintf(gl_lumpname, "GL_E%iM%i", episode, map); // figgi
+  }
+
+  lumpnum = W_GetNumForName(lumpname);
+  gl_lumpnum = W_CheckNumForName(gl_lumpname); // figgi
+
+  leveltime = 0; totallive = 0;
+
+  // note: most of this ordering is important
+
+  // killough 3/1/98: P_LoadBlockMap call moved down to below
+  // killough 4/4/98: split load of sidedefs into two parts,
+  // to allow texture names to be used in special linedefs
+
+  // refuse to load Hexen-format maps, avoid segfaults
+  if ((i = lumpnum + ML_BLOCKMAP + 1) < numlumps
+      && !strncasecmp(lumpinfo[i].name, "BEHAVIOR", 8))
+    I_Error("P_SetupLevel: %s: Hexen format not supported", lumpname);
+
+#if 1
+  // figgi 10/19/00 -- check for gl lumps and load them
+  P_GetNodesVersion(lumpnum,gl_lumpnum);
+
+  if (nodesVersion > 0)
+    P_LoadVertexes2 (lumpnum+ML_VERTEXES,gl_lumpnum+ML_GL_VERTS);
+  else
+    P_LoadVertexes  (lumpnum+ML_VERTEXES);
+  P_LoadSectors   (lumpnum+ML_SECTORS);
+  P_LoadSideDefs  (lumpnum+ML_SIDEDEFS);
+  P_LoadLineDefs  (lumpnum+ML_LINEDEFS);
+  P_LoadSideDefs2 (lumpnum+ML_SIDEDEFS);
+  P_LoadLineDefs2 (lumpnum+ML_LINEDEFS);
+  P_LoadBlockMap  (lumpnum+ML_BLOCKMAP);
+
+  if (nodesVersion > 0)
+  {
+    P_LoadSubsectors(gl_lumpnum + ML_GL_SSECT);
+    P_LoadNodes(gl_lumpnum + ML_GL_NODES);
+    P_LoadGLSegs(gl_lumpnum + ML_GL_SEGS);
+  }
+  else
+  {
+    P_LoadSubsectors(lumpnum + ML_SSECTORS);
+    P_LoadNodes(lumpnum + ML_NODES);
+    P_LoadSegs(lumpnum + ML_SEGS);
+  }
+
+#else
+
+  P_LoadVertexes  (lumpnum+ML_VERTEXES);
+  P_LoadSectors   (lumpnum+ML_SECTORS);
+  P_LoadSideDefs  (lumpnum+ML_SIDEDEFS);             // killough 4/4/98
+  P_LoadLineDefs  (lumpnum+ML_LINEDEFS);             //       |
+  P_LoadSideDefs2 (lumpnum+ML_SIDEDEFS);             //       |
+  P_LoadLineDefs2 (lumpnum+ML_LINEDEFS);             // killough 4/4/98
+  P_LoadBlockMap  (lumpnum+ML_BLOCKMAP);             // killough 3/1/98
+  P_LoadSubsectors(lumpnum+ML_SSECTORS);
+  P_LoadNodes     (lumpnum+ML_NODES);
+  P_LoadSegs      (lumpnum+ML_SEGS);
+
+#endif
+
+  // reject loading and underflow padding separated out into new function
+  // P_GroupLines modified to return a number the underflow padding needs
+  P_LoadReject(lumpnum, P_GroupLines());
+
+  // e6y
+  // Correction of desync on dv04-423.lmp/dv.wad
+  // http://www.doomworld.com/vb/showthread.php?s=&postid=627257#post627257
+  if (compatibility_level>=lxdoom_1_compatibility || M_CheckParm("-force_remove_slime_trails") > 0)
+    P_RemoveSlimeTrails();    // killough 10/98: remove slime trails from wad
+
+  // Note: you don't need to clear player queue slots --
+  // a much simpler fix is in g_game.c -- killough 10/98
+
+  bodyqueslot = 0;
+
+  /* cph - reset all multiplayer starts */
+  memset(playerstarts,0,sizeof(playerstarts));
+  deathmatch_p = deathmatchstarts;
+  for (i = 0; i < MAXPLAYERS; i++)
+    players[i].mo = NULL;
+
+  P_MapStart();
+
+  P_LoadThings(lumpnum+ML_THINGS);
+
+  // if deathmatch, randomly spawn the active players
+  if (deathmatch)
+  {
+    for (i=0; i<MAXPLAYERS; i++)
+      if (playeringame[i])
+        {
+          players[i].mo = NULL; // not needed? - done before P_LoadThings
+          G_DeathMatchSpawnPlayer(i);
+        }
+  }
+  else // if !deathmatch, check all necessary player starts actually exist
+  {
+    for (i=0; i<MAXPLAYERS; i++)
+      if (playeringame[i] && !players[i].mo)
+        I_Error("P_SetupLevel: missing player %d start\n", i+1);
+  }
+
+  // killough 3/26/98: Spawn icon landings:
+  if (gamemode==commercial)
+    P_SpawnBrainTargets();
+
+  // clear special respawning que
+  iquehead = iquetail = 0;
+
+  // set up world state
+  P_SpawnSpecials();
+
+  P_MapEnd();
+
+  // preload graphics
+  if (precache)
+    R_PrecacheLevel();
+
+#ifdef GL_DOOM
+  if (V_GetMode() == VID_MODEGL)
+  {
+    // proff 11/99: calculate all OpenGL specific tables etc.
+    gld_PreprocessLevel();
+  }
+#endif
+
+  R_SmoothPlaying_Reset(NULL); // e6y
+}
+
+//
+// P_Init
+//
+void P_Init (void)
+{
+  P_InitSwitchList();
+  P_InitPicAnims();
+  R_InitSprites(sprnames);
+}