/* saveblocks.m */

#include "idbsp.h"

short               datalist[0x10000],
                   *data_p;

/*
   short *datalist;
   short *data_p;
 */
float               orgx,
                    orgy;

#define BLOCKSIZE       128


float               xl,
                    xh,
                    yl,
                    yh;

boolean             LineContact(worldline_t * wl)
{
	NXPoint            *p1,
	                   *p2,
	                    pt1,
	                    pt2;
	float               lxl,
	                    lxh,
	                    lyl,
	                    lyh;
	divline_t           ld;
	int                 s1,
	                    s2;

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

	if (p1 -> x < p2 -> x)
		{
		lxl = p1 -> x;
		lxh = p2 -> x;
		}
	else
		{
		lxl = p2 -> x;
		lxh = p1 -> x;
		}
	if (p1 -> y < p2 -> y)
		{
		lyl = p1 -> y;
		lyh = p2 -> y;
		}
	else
		{
		lyl = p2 -> y;
		lyh = p1 -> y;
		}

	if (lxl >= xh || lxh < xl || lyl >= yh || lyh < yl)
		return false;				   /* no bbox intersections */

	if (ld.dy / ld.dx > 0)
		{							   /* positive slope */
		pt1.x = xl;
		pt1.y = yh;
		pt2.x = xh;
		pt2.y = yl;
		}
	else
		{							   /* negetive slope */
		pt1.x = xh;
		pt1.y = yh;
		pt2.x = xl;
		pt2.y = yl;
		}

	s1 = PointOnSide(&pt1, &ld);
	s2 = PointOnSide(&pt2, &ld);

	return s1 != s2;
}


/*
   ================
   =
   = GenerateBlockList
   =
   ================
 */

void                GenerateBlockList(int x, int y)
{
	NXRect              r;
	worldline_t        *wl;
	int                 count,
	                    i;

	*data_p++ = 0;					   /* leave space for thing links */

	xl = orgx + x * BLOCKSIZE;
	xh = xl + BLOCKSIZE;
	yl = orgy + y * BLOCKSIZE;
	yh = yl + BLOCKSIZE;

	r.origin.x = xl;
	r.origin.y = yl;
	r.size.width = r.size.height = BLOCKSIZE;
/*
   if (draw)
   NXEraseRect (&r);
 */
/*
   count = [linestore_i count];
   wl = [linestore_i elementAt: 0];
 */
	count = linestore_i -> count;
	wl = linestore_i -> data;
	for (i = 0; i < count; i++, wl++)
		{
		if (wl -> p1.x == wl -> p2.x)
			{						   /* vertical */
			if (wl -> p1.x < xl || wl -> p1.x >= xh)
				continue;
			if (wl -> p1.y < wl -> p2.y)
				{
				if (wl -> p1.y >= yh || wl -> p2.y < yl)
					continue;
				}
			else
				{
				if (wl -> p2.y >= yh || wl -> p1.y < yl)
					continue;
				}
			/*    *data_p++ = SHORT(i); */
			*data_p++ = i;
			continue;
			}
		if (wl -> p1.y == wl -> p2.y)
			{						   /* horizontal */
			if (wl -> p1.y < yl || wl -> p1.y >= yh)
				continue;
			if (wl -> p1.x < wl -> p2.x)
				{
				if (wl -> p1.x >= xh || wl -> p2.x < xl)
					continue;
				}
			else
				{
				if (wl -> p2.x >= xh || wl -> p1.x < xl)
					continue;
				}
			/*       *data_p++ = SHORT(i); */
			*data_p++ = i;
			continue;
			}
		/* diagonal */
		if (LineContact(wl))
			/*      *data_p++ = SHORT(i); */
			*data_p++ = i;
		}

	*data_p++ = -1;					   /* end of list marker */
}


/*
   ================
   =
   = SaveBlocks
   =
   block lump holds:
   orgx
   orgy
   blockwidth
   blockheight
   listoffset[blockwidth*blockheight]
   lists
   one short left blank for thing list
   linedef numbers
   -1 terminator

   ================
 */

void                SaveBlocks(void)
{
	int                 blockwidth,
	                    blockheight;
	int                 x,
	                    y,
	                    len;
	short              *pointer_p;

	blockwidth = (worldbounds.size.width + BLOCKSIZE - 1) / BLOCKSIZE;
	blockheight = (worldbounds.size.height + BLOCKSIZE - 1) / BLOCKSIZE;
	orgx = worldbounds.origin.x;
	orgy = worldbounds.origin.y;

	pointer_p = datalist;
/*
   *pointer_p++ = SHORT(orgx);
   *pointer_p++ = SHORT(orgy);
   *pointer_p++ = SHORT(blockwidth);
   *pointer_p++ = SHORT(blockheight);
 */
	*pointer_p++ = orgx;
	*pointer_p++ = orgy;
	*pointer_p++ = blockwidth;
	*pointer_p++ = blockheight;

	data_p = pointer_p + blockwidth * blockheight;

	for (y = 0; y < blockheight; y++)
		for (x = 0; x < blockwidth; x++)
			{
			len = data_p - datalist;
			/*    *pointer_p++ = SHORT(len); */
			*pointer_p++ = len;
			GenerateBlockList(x, y);
			}

	len = 2 * (data_p - datalist);

	printf("blockmap: (%i, %i) = %i\n", blockwidth, blockheight, len);

#if 0
	{
		int                 outhandle;

		outhandle = SafeOpenWrite("blockmap.lmp");
		SafeWrite(outhandle, datalist, len);
		close(outhandle);
	}
#endif

/*      [wad_i addName: "blockmap" data:datalist size:len]; */
	addName("blockmap", datalist, len);

}