/* doomload.m */
#include "idbsp.h"


int                 linenum = 0;
STORAGE            *linestore_i,
                   *thingstore_i;

/*
   =================
   =
   = ReadLine
   =
   =================
 */

/* worldline_t *ReadLine (FILE *file) */
worldline_t        *ReadLine(FILE * file, worldline_t * line)
{
/*      worldline_t     *line; */
	NXPoint            *p1,
	                   *p2;
	worldside_t        *s;
	sectordef_t        *e;
	int                 i;

/*      line = malloc(sizeof(worldline_t)); */
	memset(line, 0, sizeof(worldline_t));

	p1 = &line -> p1;
	p2 = &line -> p2;

	if (fscanf(file, "(%f,%f) to (%f,%f) : %d : %d : %d\n"
			,&p1 -> x, &p1 -> y, &p2 -> x, &p2 -> y, &line -> flags
			,&line -> special, &line -> tag) != 7)
		Error("Failed ReadLine");

	for (i = 0; i <= ((line -> flags & ML_TWOSIDED) != 0); i++)
		{
		s = &line -> side[i];
		if (fscanf(file, "    %d (%d : %s / %s / %s )\n"
				,&s -> firstrow, &s -> firstcollumn, s -> toptexture, s -> bottomtexture, s -> midtexture) != 5)
			Error("Failed ReadLine (side)");
		e = &s -> sectordef;
		if (fscanf(file, "    %d : %s %d : %s %d %d %d\n"
				,&e -> floorheight, e -> floorflat, &e -> ceilingheight
				,e -> ceilingflat, &e -> lightlevel, &e -> special, &e -> tag) != 7)
			Error("Failed ReadLine (sector)");
		if (!strcmp(e -> floorflat, "-"))
			printf("WARNING: line %i has no sectordef\n", linenum);
		}

	linenum++;

	return line;
}

/*
   =================
   =
   = ReadThing
   =
   =================
 */

/* worldthing_t *ReadThing (FILE *file) */
worldthing_t       *ReadThing(FILE * file, worldthing_t * thing)
{
	int                 x,
	                    y;

/*      worldthing_t    *thing; */

/*      thing = malloc(sizeof(*thing)); */
	memset(thing, 0, sizeof(*thing));

	if (fscanf(file, "(%i,%i, %d) :%d, %d\n"
			,&x, &y, &thing -> angle, &thing -> type, &thing -> options) != 5)
		Error("Failed ReadThing");

	thing -> origin.x = x & -16;
	thing -> origin.y = y & -16;

	return thing;
}

/*
   ==================
   =
   = LineOverlaid
   =
   = Check to see if the line is colinear and overlapping any previous lines
   ==================
 */

typedef struct
{
	float               left,
	                    right,
	                    top,
	                    bottom;
}

bbox_t;

void                BBoxFromPoints(bbox_t * box, NXPoint * p1, NXPoint * p2)
{
	if (p1 -> x < p2 -> x)
		{
		box -> left = p1 -> x;
		box -> right = p2 -> x;
		}
	else
		{
		box -> left = p2 -> x;
		box -> right = p1 -> x;
		}
	if (p1 -> y < p2 -> y)
		{
		box -> bottom = p1 -> y;
		box -> top = p2 -> y;
		}
	else
		{
		box -> bottom = p2 -> y;
		box -> top = p1 -> y;
		}
}

boolean             LineOverlaid(worldline_t * line)
{
	int                 j,
	                    count;
	worldline_t        *scan;
	divline_t           wl;
	bbox_t              linebox,
	                    scanbox;

	wl.pt = line -> p1;
	wl.dx = line -> p2.x - line -> p1.x;
	wl.dy = line -> p2.y - line -> p1.y;

/*
   count = [linestore_i count];
   scan = [linestore_i elementAt:0];
 */
	count = linestore_i -> count;
	scan = linestore_i -> data;

	for (j = 0; j < count; j++, scan++)
		{
		if (PointOnSide(&scan -> p1, &wl) != -1)
			continue;
		if (PointOnSide(&scan -> p2, &wl) != -1)
			continue;
/* line is colinear, see if it overlapps */
		BBoxFromPoints(&linebox, &line -> p1, &line -> p2);
		BBoxFromPoints(&scanbox, &scan -> p1, &scan -> p2);

		if (linebox.right > scanbox.left && linebox.left < scanbox.right)
			return true;
		if (linebox.bottom < scanbox.top && linebox.top > scanbox.bottom)
			return true;
		}
	return false;
}

/*
   ===================
   =
   = LoadDoomMap
   =
   ===================
 */

/* id   linestore_i, thingstore_i; */

/* void LoadDoomMap (char *mapname) */
void                LoadDoomMap(FILE * file)
{
/*      FILE            *file; */
/*              int                     i, version; */
	int                 i;
	int                 linecount,
	                    thingcount;
	worldline_t        *line;
	worldthing_t       *thing;

/*
   file = fopen (mapname,"r");
   if (!file)
   Error ("LoadDoomMap: couldn't open %s", mapname);
 */
/*
   if (!fscanf (file, "WorldServer version %d\n", &version) || version != 4)
   Error ("LoadDoomMap: not a version 4 doom map");
   printf ( "Loading version 4 doom map\n");
 */
/*
   read lines
 */
	if (fscanf(file, "\nlines:%d\n", &linecount) != 1)
		Error("LoadDoomMap: can't read linecount");
	printf("%i lines\n", linecount);
/*
   linestore_i = [[Storage alloc]
   initCount:              0
   elementSize:    sizeof(worldline_t)
   description:    NULL];
 */
	linestore_i = (STORAGE *) SafeMalloc(sizeof(STORAGE));
	linestore_i -> data = (worldline_t *) SafeCalloc(linecount, sizeof(worldline_t));
	linestore_i -> size = sizeof(worldline_t);
	linestore_i -> count = 0;

	line = linestore_i -> data;
	printf("\n");
	for (i = 0; i < linecount; i++, linestore_i -> count++, line++)
		{
/*              line = ReadLine (file); */
		printf("Reading line #%d\r", i);
		ReadLine(file, line);
		if (line -> p1.x == line -> p2.x && line -> p1.y == line -> p2.y)
			{
			printf("WARNING: line %i is length 0 (removed)\n", i);
			continue;
			}

		if (LineOverlaid(line))
			{
			printf("WARNING: line %i is overlaid (removed)\n", i);
			continue;
			}

/*
   [linestore_i addElement: line];
 */
/*
   linestore_i->count += 1;
   linestore_i->data = (worldline_t *)realloc(linestore_i->data,
   sizeof(worldline_t) * (linestore_i->count + 1));
   line = (worldline_t *)linestore_i->data + linestore_i->count;
 */
		}

/*
   read things
 */
	if (fscanf(file, "\nthings:%d\n", &thingcount) != 1)
		Error("LoadDoomMap: can't read thingcount");
	printf("\n\n%i things\n", thingcount);
/*
   thingstore_i = [[Storage alloc]
   initCount:              0
   elementSize:    sizeof(worldthing_t)
   description:    NULL];
 */
	thingstore_i = (STORAGE *) SafeMalloc(sizeof(STORAGE));
	thingstore_i -> data = (worldthing_t *) SafeCalloc(thingcount, sizeof(worldthing_t));
	thingstore_i -> size = sizeof(worldthing_t);
	thingstore_i -> count = thingcount;
/*
   for (i=0 ; i<thingcount ; i++)
   [thingstore_i addElement: ReadThing (file)];
 */
	thing = thingstore_i -> data;
	for (i = 0; i < thingcount; i++)
		{
		printf("Reading thing #%d\r", i);
		ReadThing(file, thing);
		thing++;
		}
/*
   fclose (file);
 */
}