- UDMF implementation for ZDBSP.

SVN r1482 (trunk)

doomdata.h

@@ -14,8 +14,8 @@ enum
 
 struct UDMFKey
 {
-	int key;
+	const char *key;
-	int value;
+	const char *value;
 };
 
 struct MapVertex
@@ -26,6 +26,7 @@ struct MapVertex
 struct WideVertex
 {
 	fixed_t x, y;
+	int index;
 };
 
 struct MapSideDef
@@ -201,12 +202,18 @@ struct IntThing
 	TArray<UDMFKey> props;
 };
 
+struct IntVertex
+{
+	TArray<UDMFKey> props;
+};
+
 struct FLevel
 {
 	FLevel ();
 	~FLevel ();
 
 	WideVertex *Vertices;		int NumVertices;
+	TArray<IntVertex>			VertexProps;
 	TArray<IntSideDef>			Sides;
 	TArray<IntLineDef>			Lines;
 	TArray<IntSector>			Sectors;
@@ -229,6 +236,8 @@ struct FLevel
 
 	fixed_t MinX, MinY, MaxX, MaxY;
 
+	TArray<UDMFKey> props;
+
 	void FindMapBounds ();
 	void RemoveExtraLines ();
 	void RemoveExtraSides ();

nodebuild.cpp

@@ -778,6 +778,7 @@ void FNodeBuilder::SplitSegs (DWORD set, node_t &node, DWORD splitseg, DWORD &ou
 			newvert.y = Vertices[seg->v1].y;
 			newvert.x += fixed_t(frac * double(Vertices[seg->v2].x - newvert.x));
 			newvert.y += fixed_t(frac * double(Vertices[seg->v2].y - newvert.y));
+			newvert.index = 0;
 			vertnum = VertexMap->SelectVertexClose (newvert);
 
 			seg2 = SplitSeg (set, vertnum, sidev1);

nodebuild.h

@@ -50,7 +50,7 @@ class FNodeBuilder
 	struct FPrivSeg
 	{
 		int v1, v2;
-		int sidedef;
+		DWORD sidedef;
 		int linedef;
 		int frontsector;
 		int backsector;
@@ -72,6 +72,7 @@ class FNodeBuilder
 		fixed_t x, y;
 		DWORD segs;		// segs that use this vertex as v1
 		DWORD segs2;	// segs that use this vertex as v2
+		int index;
 
 		bool operator== (const FPrivVert &other)
 		{

nodebuild_extract.cpp

@@ -358,7 +358,7 @@ void FNodeBuilder::PushConnectingGLSeg (int subsector, TArray<MapSegGLEx> &segs,
 
 	newseg.v1 = v1;
 	newseg.v2 = v2;
-	newseg.linedef = NO_INDEX;
+	newseg.linedef = NO_MAP_INDEX;
 	newseg.side = 0;
 	newseg.partner = DWORD_MAX;
 	segs.Push (newseg);
@@ -373,6 +373,7 @@ void FNodeBuilder::GetVertices (WideVertex *&verts, int &count)
 	{
 		verts[i].x = Vertices[i].x;
 		verts[i].y = Vertices[i].y;
+		verts[i].index = Vertices[i].index;
 	}
 }
 

nodebuild_utility.cpp

@@ -62,12 +62,14 @@ void FNodeBuilder::FindUsedVertices (WideVertex *oldverts, int max)
 		{
 			newvert.x = oldverts[v1].x;
 			newvert.y = oldverts[v1].y;
+			newvert.index = oldverts[v1].index;
 			map[v1] = VertexMap->SelectVertexExact (newvert);
 		}
 		if (map[v2] == -1)
 		{
 			newvert.x = oldverts[v2].x;
 			newvert.y = oldverts[v2].y;
+			newvert.index = oldverts[v2].index;
 			map[v2] = VertexMap->SelectVertexExact (newvert);
 		}
 

processor.cpp

@@ -179,8 +179,8 @@ void FProcessor::LoadLines ()
 			Level.Lines[i].flags = LittleShort(Lines[i].flags);
 			Level.Lines[i].sidenum[0] = LittleShort(Lines[i].sidenum[0]);
 			Level.Lines[i].sidenum[1] = LittleShort(Lines[i].sidenum[1]);
-			if (Level.Lines[i].sidenum[0] == 0xffff) Level.Lines[i].sidenum[0] = NO_INDEX;
+			if (Level.Lines[i].sidenum[0] == NO_MAP_INDEX) Level.Lines[i].sidenum[0] = NO_INDEX;
-			if (Level.Lines[i].sidenum[1] == 0xffff) Level.Lines[i].sidenum[1] = NO_INDEX;
+			if (Level.Lines[i].sidenum[1] == NO_MAP_INDEX) Level.Lines[i].sidenum[1] = NO_INDEX;
 		}
 		delete[] Lines;
 	}
@@ -197,8 +197,8 @@ void FProcessor::LoadLines ()
 			Level.Lines[i].flags = LittleShort(ml[i].flags);
 			Level.Lines[i].sidenum[0] = LittleShort(ml[i].sidenum[0]);
 			Level.Lines[i].sidenum[1] = LittleShort(ml[i].sidenum[1]);
-			if (Level.Lines[i].sidenum[0] == 0xffff) Level.Lines[i].sidenum[0] = NO_INDEX;
+			if (Level.Lines[i].sidenum[0] == NO_MAP_INDEX) Level.Lines[i].sidenum[0] = NO_INDEX;
-			if (Level.Lines[i].sidenum[1] == 0xffff) Level.Lines[i].sidenum[1] = NO_INDEX;
+			if (Level.Lines[i].sidenum[1] == NO_MAP_INDEX) Level.Lines[i].sidenum[1] = NO_INDEX;
 
 			// Store the special and tag in the args array so we don't lose them
 			Level.Lines[i].special = 0;
@@ -220,6 +220,7 @@ void FProcessor::LoadVertices ()
 	{
 		Level.Vertices[i].x = LittleShort(verts[i].x) << FRACBITS;
 		Level.Vertices[i].y = LittleShort(verts[i].y) << FRACBITS;
+		Level.Vertices[i].index = 0; // we don't need this value for non-UDMF maps
 	}
 }
 
@@ -239,7 +240,7 @@ void FProcessor::LoadSides ()
 		memcpy(Level.Sides[i].midtexture, Sides[i].midtexture, 8);
 
 		Level.Sides[i].sector = LittleShort(Sides[i].sector);
-		if (Level.Sides[i].sector == 0xffff) Level.Sides[i].sector = NO_INDEX;
+		if (Level.Sides[i].sector == NO_MAP_INDEX) Level.Sides[i].sector = NO_INDEX;
 	}
 	delete [] Sides;
 }
@@ -531,6 +532,11 @@ void FProcessor::Write (FWadWriter &out)
 		}
 		else
 		{
+			for(int i=Lump; stricmp(Wad.LumpName(i), "ENDMAP") && i < Wad.NumLumps(); i++)
+			{
+				out.CopyLump(Wad, i);
+			}
+			out.CreateLabel("ENDMAP");
 		}
 		return;
 	}
@@ -557,8 +563,15 @@ void FProcessor::Write (FWadWriter &out)
 	{
 		FNodeBuilder *builder = NULL;
 
-		// UDMF spec requires GL nodes.
+		// ZDoom's UDMF spec requires compressed GL nodes.
-		if (isUDMF) BuildGLNodes = true;
+		// No other UDMF spec has defined anything regarding nodes yet.
+		if (isUDMF) 
+		{
+			BuildGLNodes = true;
+			ConformNodes = false;
+			GLOnly = true;
+			CompressGLNodes = true;
+		}
 		
 		try
 		{
@@ -641,6 +654,8 @@ void FProcessor::Write (FWadWriter &out)
 		}
 	}
 
+	if (!isUDMF)
+	{
 		FBlockmapBuilder bbuilder (Level);
 		WORD *blocks = bbuilder.GetBlockmap (Level.BlockmapSize);
 		Level.Blockmap = new WORD[Level.BlockmapSize];
@@ -695,6 +710,7 @@ void FProcessor::Write (FWadWriter &out)
 			memset (Level.Reject, 0, Level.RejectSize);
 			break;
 		}
+	}
 
 	if (ShowMap)
 	{
@@ -712,6 +728,9 @@ void FProcessor::Write (FWadWriter &out)
 #endif
 	}
 	
+	if (!isUDMF)
+	{
+
 		if (Level.GLNodes != NULL )
 		{
 			gl5 = V5GLNodes ||
@@ -804,6 +823,11 @@ void FProcessor::Write (FWadWriter &out)
 			WriteGLSSect (out, gl5);
 			WriteGLNodes (out, gl5);
 		}
+	}
+	else
+	{
+		WriteUDMF(out);
+	}
 }
 
 //

processor.h

@@ -87,6 +87,26 @@ private:
 	void WriteNodes5 (FWadWriter &out, const char *name, const MapNodeEx *zaNodes, int count) const;
 	void WriteSSectors5 (FWadWriter &out, const char *name, const MapSubsectorEx *zaSubs, int count) const;
 
+	const char *ParseKey(const char *&value);
+	bool CheckKey(const char *&key, const char *&value);
+	void ParseThing(IntThing *th);
+	void ParseLinedef(IntLineDef *ld);
+	void ParseSidedef(IntSideDef *sd);
+	void ParseSector(IntSector *sec);
+	void ParseVertex(WideVertex *vt, IntVertex *vtp);
+	void ParseMapProperties();
+	void ParseTextMap(int lump);
+
+	void WriteProps(FWadWriter &out, TArray<UDMFKey> &props);
+	void WriteIntProp(FWadWriter &out, const char *key, int value);
+	void WriteThingUDMF(FWadWriter &out, IntThing *th);
+	void WriteLinedefUDMF(FWadWriter &out, IntLineDef *ld);
+	void WriteSidedefUDMF(FWadWriter &out, IntSideDef *sd);
+	void WriteSectorUDMF(FWadWriter &out, IntSector *sec);
+	void WriteVertexUDMF(FWadWriter &out, IntVertex *vt);
+	void WriteTextMap(FWadWriter &out);
+	void WriteUDMF(FWadWriter &out);
+
 	FLevel Level;
 
 	TArray<FNodeBuilder::FPolyStart> PolyStarts;

processor_udmf.cpp

@@ -1,7 +1,559 @@
+/*
+    Reads and writes UDMF maps
+    Copyright (C) 2009 Christoph Oelckers
 
+    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., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+
+#include <float.h>
 #include "processor.h"
+#include "sc_man.h"
 
 
+class StringBuffer
+{
+	const static int BLOCK_SIZE = 100000;
+	const static int BLOCK_ALIGN = sizeof(size_t);
+
+	TDeletingArray<char *> blocks;
+	size_t currentindex;
+
+	char *Alloc(size_t size)
+	{
+		if (currentindex + size >= BLOCK_SIZE)
+		{
+			// Block is full - get a new one!
+			char *newblock = new char[BLOCK_SIZE];
+			blocks.Push(newblock);
+			currentindex = 0;
+		}
+		size = (size + BLOCK_ALIGN-1) &~ (BLOCK_ALIGN-1);
+		char *p = blocks[blocks.Size()-1] + currentindex;
+		currentindex += size;
+		return p;
+	}
+public:
+
+	StringBuffer()
+	{
+		currentindex = BLOCK_SIZE;
+	}
+
+	char * Copy(const char * p)
+	{
+		return p != NULL? strcpy(Alloc(strlen(p)+1) , p) : NULL;
+	}
+};
+
+StringBuffer stbuf;
+
+
+//===========================================================================
+//
+// Parses a 'key = value;' line of the map
+//
+//===========================================================================
+
+const char *FProcessor::ParseKey(const char *&value)
+{
+	SC_MustGetString();
+	const char *key = stbuf.Copy(sc_String);
+	SC_MustGetStringName("=");
+
+	sc_Number = INT_MIN;
+	sc_Float = DBL_MIN;
+	if (!SC_CheckFloat())
+	{
+		SC_MustGetString();
+	}
+	value = stbuf.Copy(sc_String);
+	SC_MustGetStringName(";");
+	return key;
+}
+
+bool FProcessor::CheckKey(const char *&key, const char *&value)
+{
+	SC_SavePos();
+	SC_MustGetString();
+	if (SC_CheckString("="))
+	{
+		SC_RestorePos();
+		key = ParseKey(value);
+		return true;
+	}
+	SC_RestorePos();
+	return false;
+}
+
+int CheckInt(const char *key)
+{
+	if (sc_Number == INT_MIN)
+	{
+		SC_ScriptError("Integer value expected for key '%s'", key);
+	}
+	return sc_Number;
+}
+
+double CheckFloat(const char *key)
+{
+	if (sc_Float == DBL_MIN)
+	{
+		SC_ScriptError("Floating point value expected for key '%s'", key);
+	}
+	return sc_Float;
+}
+
+fixed_t CheckFixed(const char *key)
+{
+	return (fixed_t)(CheckFloat(key)*65536.);
+}
+
+//===========================================================================
+//
+// Parse a thing block
+//
+//===========================================================================
+
+void FProcessor::ParseThing(IntThing *th)
+{
+	SC_MustGetStringName("{");
+	while (!SC_CheckString("}"))
+	{
+		const char *value;
+		const char *key = ParseKey(value);
+
+		// The only properties we need from a thing are
+		// x, y, angle and type.
+
+		if (!stricmp(key, "x"))
+		{
+			th->x = CheckFixed(key);
+		}
+		else if (!stricmp(key, "y"))
+		{
+			th->y = CheckFixed(key);
+		}
+		if (!stricmp(key, "angle"))
+		{
+			th->angle = (short)CheckInt(key);
+		}
+		if (!stricmp(key, "type"))
+		{
+			th->type = (short)CheckInt(key);
+		}
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		th->props.Push(k);
+	}
+}
+
+//===========================================================================
+//
+// Parse a linedef block
+//
+//===========================================================================
+
+void FProcessor::ParseLinedef(IntLineDef *ld)
+{
+	SC_MustGetStringName("{");
+	ld->v1 = ld->v2 = ld->sidenum[0] = ld->sidenum[1] = NO_INDEX;
+	ld->special = 0;
+	while (!SC_CheckString("}"))
+	{
+		const char *value;
+		const char *key = ParseKey(value);
+
+		if (!stricmp(key, "v1"))
+		{
+			ld->v1 = CheckInt(key);
+			continue;	// do not store in props
+		}
+		else if (!stricmp(key, "v2"))
+		{
+			ld->v2 = CheckInt(key);
+			continue;	// do not store in props
+		}
+		else if (Extended && !stricmp(key, "special"))
+		{
+			ld->special = CheckInt(key);
+		}
+		else if (Extended && !stricmp(key, "arg0"))
+		{
+			ld->args[0] = CheckInt(key);
+		}
+		if (!stricmp(key, "sidefront"))
+		{
+			ld->sidenum[0] = CheckInt(key);
+			continue;	// do not store in props
+		}
+		else if (!stricmp(key, "sideback"))
+		{
+			ld->sidenum[1] = CheckInt(key);
+			continue;	// do not store in props
+		}
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		ld->props.Push(k);
+	}
+}
+
+//===========================================================================
+//
+// Parse a sidedef block
+//
+//===========================================================================
+
+void FProcessor::ParseSidedef(IntSideDef *sd)
+{
+	SC_MustGetStringName("{");
+	sd->sector = NO_INDEX;
+	while (!SC_CheckString("}"))
+	{
+		const char *value;
+		const char *key = ParseKey(value);
+
+		if (!stricmp(key, "sector"))
+		{
+			sd->sector = CheckInt(key);
+			continue;	// do not store in props
+		}
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		sd->props.Push(k);
+	}
+}
+
+//===========================================================================
+//
+// Parse a sidedef block
+//
+//===========================================================================
+
+void FProcessor::ParseSector(IntSector *sec)
+{
+	SC_MustGetStringName("{");
+	while (!SC_CheckString("}"))
+	{
+		const char *value;
+		const char *key = ParseKey(value);
+
+		// No specific sector properties are ever used by the node builder
+		// so everything can go directly to the props array.
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		sec->props.Push(k);
+	}
+}
+
+//===========================================================================
+//
+// parse a vertex block
+//
+//===========================================================================
+
+void FProcessor::ParseVertex(WideVertex *vt, IntVertex *vtp)
+{
+	vt->x = vt->y = 0;
+	SC_MustGetStringName("{");
+	while (!SC_CheckString("}"))
+	{
+		const char *value;
+		const char *key = ParseKey(value);
+
+		if (!stricmp(key, "x"))
+		{
+			vt->x = CheckFixed(key);
+		}
+		else if (!stricmp(key, "y"))
+		{
+			vt->y = CheckFixed(key);
+		}
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		vtp->props.Push(k);
+	}
+}
+
+
+//===========================================================================
+//
+// parses global map properties
+//
+//===========================================================================
+
+void FProcessor::ParseMapProperties()
+{
+	const char *key, *value;
+
+	// all global keys must come before the first map element.
+
+	while (CheckKey(key, value))
+	{
+		if (!stricmp(key, "namespace"))
+		{
+			// all unknown namespaces are assumed to be standard.
+			Extended = !stricmp(value, "ZDoom") || !stricmp(value, "Hexen") || !stricmp(value, "Vavoom");
+		}
+
+		// now store the key in its unprocessed form
+		UDMFKey k = {key, value};
+		Level.props.Push(k);
+	}
+}
+
+
+//===========================================================================
+//
+// Main parsing function
+//
+//===========================================================================
+
+void FProcessor::ParseTextMap(int lump)
+{
+	char *buffer;
+	int buffersize;
+	TArray<WideVertex> Vertices;
+
+	ReadLump<char> (Wad, lump, buffer, buffersize);
+	SC_OpenMem("TEXTMAP", buffer, buffersize);
+
+	SC_SetCMode(true);
+	ParseMapProperties();
+
+	while (SC_GetString())
+	{
+		if (SC_Compare("thing"))
+		{
+			IntThing *th = &Level.Things[Level.Things.Reserve(1)];
+			ParseThing(th);
+		}
+		else if (SC_Compare("linedef"))
+		{
+			IntLineDef *ld = &Level.Lines[Level.Lines.Reserve(1)];
+			ParseLinedef(ld);
+		}
+		else if (SC_Compare("sidedef"))
+		{
+			IntSideDef *sd = &Level.Sides[Level.Sides.Reserve(1)];
+			ParseSidedef(sd);
+		}
+		else if (SC_Compare("sector"))
+		{
+			IntSector *sec = &Level.Sectors[Level.Sectors.Reserve(1)];
+			ParseSector(sec);
+		}
+		else if (SC_Compare("vertex"))
+		{
+			WideVertex *vt = &Vertices[Vertices.Reserve(1)];
+			IntVertex *vtp = &Level.VertexProps[Level.VertexProps.Reserve(1)];
+			vt->index = Vertices.Size();
+			ParseVertex(vt, vtp);
+		}
+	}
+	Level.Vertices = new WideVertex[Vertices.Size()];
+	Level.NumVertices = Vertices.Size();
+	memcpy(Level.Vertices, &Vertices[0], Vertices.Size() * sizeof(WideVertex));
+	SC_Close();
+	delete[] buffer;
+}
+
+
+//===========================================================================
+//
+// parse an UDMF map
+//
+//===========================================================================
+
 void FProcessor::LoadUDMF()
 {
+	ParseTextMap(Lump+1);
+}
+
+//===========================================================================
+//
+// writes a property list
+//
+//===========================================================================
+
+void FProcessor::WriteProps(FWadWriter &out, TArray<UDMFKey> &props)
+{
+	for(unsigned i=0; i< props.Size(); i++)
+	{
+		out.AddToLump(props[i].key, (int)strlen(props[i].key));
+		out.AddToLump(" = ", 3);
+		out.AddToLump(props[i].value, (int)strlen(props[i].value));
+		out.AddToLump(";\n", 2);
+	}
+}
+
+//===========================================================================
+//
+// writes an integer property
+//
+//===========================================================================
+
+void FProcessor::WriteIntProp(FWadWriter &out, const char *key, int value)
+{
+	char buffer[20];
+
+	out.AddToLump(key, (int)strlen(key));
+	out.AddToLump(" = ", 3);
+	sprintf(buffer, "%d;\n", value);
+	out.AddToLump(buffer, (int)strlen(buffer));
+}
+
+//===========================================================================
+//
+// writes an UDMF thing
+//
+//===========================================================================
+
+void FProcessor::WriteThingUDMF(FWadWriter &out, IntThing *th)
+{
+	out.AddToLump("thing\n{\n", 8);
+	WriteProps(out, th->props);
+	out.AddToLump("}\n\n", 3);
+}
+
+//===========================================================================
+//
+// writes an UDMF linedef
+//
+//===========================================================================
+
+void FProcessor::WriteLinedefUDMF(FWadWriter &out, IntLineDef *ld)
+{
+	out.AddToLump("linedef\n{\n", 10);
+	WriteIntProp(out, "v1", ld->v1);
+	WriteIntProp(out, "v2", ld->v2);
+	if (ld->sidenum[0] != NO_INDEX) WriteIntProp(out, "sidefront", ld->sidenum[0]);
+	if (ld->sidenum[1] != NO_INDEX) WriteIntProp(out, "sideback", ld->sidenum[1]);
+	WriteProps(out, ld->props);
+	out.AddToLump("}\n\n", 3);
+}
+
+//===========================================================================
+//
+// writes an UDMF sidedef
+//
+//===========================================================================
+
+void FProcessor::WriteSidedefUDMF(FWadWriter &out, IntSideDef *sd)
+{
+	out.AddToLump("sidedef\n{\n", 10);
+	WriteIntProp(out, "sector", sd->sector);
+	WriteProps(out, sd->props);
+	out.AddToLump("}\n\n", 3);
+}
+
+//===========================================================================
+//
+// writes an UDMF sector
+//
+//===========================================================================
+
+void FProcessor::WriteSectorUDMF(FWadWriter &out, IntSector *sec)
+{
+	out.AddToLump("sector\n{\n", 9);
+	WriteProps(out, sec->props);
+	out.AddToLump("}\n\n", 3);
+}
+
+//===========================================================================
+//
+// writes an UDMF vertex
+//
+//===========================================================================
+
+void FProcessor::WriteVertexUDMF(FWadWriter &out, IntVertex *vt)
+{
+	out.AddToLump("vertex\n{\n", 9);
+	WriteProps(out, vt->props);
+	out.AddToLump("}\n\n", 3);
+}
+
+//===========================================================================
+//
+// writes an UDMF vertex
+//
+//===========================================================================
+
+void FProcessor::WriteTextMap(FWadWriter &out)
+{
+	out.StartWritingLump("TEXTMAP");
+	WriteProps(out, Level.props);
+	for(int i = 0; i < Level.NumThings(); i++)
+	{
+		WriteThingUDMF(out, &Level.Things[i]);
+	}
+
+	for(int i = 0; i < Level.NumOrgVerts; i++)
+	{
+		WideVertex *vt = &Level.Vertices[i];
+		if (vt->index <= 0)
+		{
+			// not valid!
+			throw std::runtime_error("Invalid vertex data.");
+		}
+		WriteVertexUDMF(out, &Level.VertexProps[vt->index-1]);
+	}
+
+	for(int i = 0; i < Level.NumLines(); i++)
+	{
+		WriteLinedefUDMF(out, &Level.Lines[i]);
+	}
+
+	for(int i = 0; i < Level.NumSides(); i++)
+	{
+		WriteSidedefUDMF(out, &Level.Sides[i]);
+	}
+
+	for(int i = 0; i < Level.NumSectors(); i++)
+	{
+		WriteSectorUDMF(out, &Level.Sectors[i]);
+	}
+}
+
+//===========================================================================
+//
+// writes an UDMF vertex
+//
+//===========================================================================
+
+void FProcessor::WriteUDMF(FWadWriter &out)
+{
+	out.CopyLump (Wad, Lump);
+	WriteTextMap(out);
+	WriteGLBSPZ (out, "ZNODES");
+	// copy everything except existing nodes, blockmap and reject
+	for(int i=Lump+2; stricmp(Wad.LumpName(i), "ENDMAP") && i < Wad.NumLumps(); i++)
+	{
+		const char *lumpname = Wad.LumpName(i);
+		if (stricmp(lumpname, "ZNODES") &&
+			stricmp(lumpname, "BLOCKMAP") &&
+			stricmp(lumpname, "REJECT"))
+		{
+			out.CopyLump(Wad, i);
+		}
+	}
+	out.CreateLabel("ENDMAP");
 }

sc_man.cpp

@@ -60,7 +60,7 @@ static void CheckOpen (void);
 char *sc_String;
 int sc_StringLen;
 int sc_Number;
-float sc_Float;
+double sc_Float;
 int sc_Line;
 bool sc_End;
 bool sc_Crossed;
@@ -87,31 +87,15 @@ static bool CMode;
 //
 // SC_OpenFile
 //
-// Loads a script (from a file). Uses the new/delete memory allocator for
+// Loads a script 
-// memory allocation and de-allocation.
 //
 //==========================================================================
 
-void SC_OpenFile (const char *name)
+void SC_OpenMem (const char *name, char *buffer, int len)
 {
 	SC_Close ();
-	FILE * f = fopen(name, "rb");
+	ScriptSize = len;
-	if (f == NULL)
+	ScriptBuffer = buffer;
-	{
-		printf("%s: file not found\n", name);
-		exit(1);
-	}
-	fseek(f, 0, SEEK_END);
-	ScriptSize = ftell(f);
-	fseek(f, 0, SEEK_SET);
-	ScriptBuffer = (char*)malloc(ScriptSize);
-	if (ScriptSize != int(fread(ScriptBuffer, 1, ScriptSize, f)))
-	{
-		fclose(f);
-		printf("%s: unable to read file\n", name);
-		exit(1);
-	}
-	fclose(f);
 	SC_PrepareScript ();
 }
 
@@ -146,10 +130,6 @@ void SC_Close (void)
 {
 	if (ScriptOpen)
 	{
-		if (ScriptBuffer)
-		{
-			free(ScriptBuffer);
-		}
 		ScriptBuffer = NULL;
 		ScriptOpen = false;
 	}
@@ -456,7 +436,7 @@ bool SC_GetNumber (void)
 				SC_ScriptError ("SC_GetNumber: Bad numeric constant \"%s\".", sc_String);
 			}
 		}
-		sc_Float = (float)sc_Number;
+		sc_Float = sc_Number;
 		return true;
 	}
 	else
@@ -507,7 +487,7 @@ bool SC_CheckNumber (void)
 				return false;
 			}
 		}
-		sc_Float = (float)sc_Number;
+		sc_Float = sc_Number;
 		return true;
 	}
 	else
@@ -530,7 +510,8 @@ bool SC_CheckFloat (void)
 	//CheckOpen ();
 	if (SC_GetString())
 	{
-		sc_Float = (float)strtod (sc_String, &stopper);
+		sc_Float = strtod (sc_String, &stopper);
+		sc_Number = (int)sc_Float;
 		if (*stopper != 0)
 		{
 			SC_UnGet();
@@ -558,7 +539,7 @@ bool SC_GetFloat (void)
 	CheckOpen ();
 	if (SC_GetString())
 	{
-		sc_Float = (float)strtod (sc_String, &stopper);
+		sc_Float = strtod (sc_String, &stopper);
 		if (*stopper != 0)
 		{
 			SC_ScriptError("SC_GetFloat: Bad numeric constant \"%s\".\n",sc_String);

sc_man.h

@@ -32,7 +32,7 @@ void SC_RestoreScriptState();
 extern char *sc_String;
 extern int sc_StringLen;
 extern int sc_Number;
-extern float sc_Float;
+extern double sc_Float;
 extern int sc_Line;
 extern bool sc_End;
 extern bool sc_Crossed;

view.cpp

@@ -1010,10 +1010,20 @@ void ShowView (FLevel *level)
 	{
 		Level = level;
 
+		if (level->Blockmap != NULL)
+		{
 			MapBounds.left = short(level->Blockmap[0]) - 8;
 			MapBounds.right = short(level->Blockmap[0]) + (level->Blockmap[2] << BLOCKBITS) + 8;
 			MapBounds.top = short(level->Blockmap[1]) - 8;
 			MapBounds.bottom = short(level->Blockmap[1]) + (level->Blockmap[3] << BLOCKBITS) + 8;
+		}
+		else
+		{
+			MapBounds.left = level->MinX >> FRACBITS;
+			MapBounds.right = level->MaxX >> FRACBITS;
+			MapBounds.top = level->MinY >> FRACBITS;
+			MapBounds.bottom = level->MaxY >> FRACBITS;
+		}
 		MapSize.x = MapBounds.right - MapBounds.left;
 		MapSize.y = MapBounds.bottom - MapBounds.top;
 		Divisor = 1;

wad.cpp

@@ -303,7 +303,7 @@ int FWadReader::LumpAfterMap (int i) const
 		{
 			i++;
 		}
-		return i;
+		return i+1;	// one lump after ENDMAP
 	}
 
 	i++;

zdbsp.h

@@ -66,8 +66,8 @@ typedef uint32_t angle_t;
 
 angle_t PointToAngle (fixed_t x, fixed_t y);
 
-static const DWORD NO_MAP_INDEX = 0xffffffff;
+static const WORD NO_MAP_INDEX = 0xffff;
-static const WORD NO_INDEX = 0xffff;
+static const DWORD NO_INDEX = 0xffffffff;
 static const angle_t ANGLE_MAX = 0xffffffff;
 static const DWORD DWORD_MAX = 0xffffffff;
 static const angle_t ANGLE_180 = (1u<<31);

zdbsp_vs2005.sln

@@ -1,6 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual Studio 2005
+# Visual C++ Express 2005
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zdbsp_vs2005", "zdbsp_vs2005.vcproj", "{E628034A-AE64-43B5-8CF4-668D07041C35}"
 EndProject
 Global