Sorry your browser is not supported!

class LEVEL_FILE_DATA
{
public:
	LEVEL_FILE_DATA(void);	// calls set_defaults
	~LEVEL_FILE_DATA(void);

	void	set_map_data(NAGAME* na);
	void	get_map_data(NAGAME* na);

private:
	void	set_defaults();

	USHORT	def_count;		// 1-MAX_DEFENSES defenses (0 if not defined/none)

	// MAP_DATA

	USHORT	max_faces;
	USHORT	rnd_seed;
	USHORT	edge_length;
	USHORT	rnd_mod;
	USHORT	rnd_add;
	USHORT	rnd_div;
	USHORT	edge_angle;		// will need converting (radians to degrees)
	UBYTE	floorImg;
	UBYTE	wallImg;
	UBYTE	roofImg;
	UBYTE	_pad_byte1;
	// (18 bytes / 17 bytes + 1)
	// total = 20 bytes

	// PERLIN_NOISE

	float	persistence;
	float	frequency;
	float	amplitude;
	USHORT	octaves;
	USHORT	randomseed;
	USHORT	perlin_height;
	// (18 bytes)
	// total = 38 bytes

	// LEVEL_DEFENSES

	struct {
		USHORT	type;
		USHORT	count;
		USHORT	seed;
	} defenses[MAX_DEFENSES];
	// (6 bytes)

	// Total with max defenses 15 is now 128 bytes
	// total 254 bytes

	//USHORT	_pad_word1;		// now upto 256 bytes per level
};

int PROC_MAP::make_floor()
{
	int obj = free_object();

	CreateNewObject( obj, "floor", 1 );

	sObject*	pObject = dbGetObject( obj );
	sFrame*		pFrame  = pObject->pFrame;
	sMesh*		pMesh	= pObject->pFrame->pMesh;

	int			vSize	= verts.size();
	int			fSize	= faces.size();

	_VERT*		pvert	= &verts[0];

	SetupMeshFVFData ( pMesh, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1, vSize, fSize * 3 );

	for ( int vcount = 0; vcount < vSize; vcount++ )
	{
		SetupStandardVertex( pMesh->dwFVF, pMesh->pVertexData, vcount,
			pvert->x, pvert->y, pvert->z,
			0, 1, 0,  0xffffffff,
			fmod( pvert->x, size_max ) / size_max,
			fmod( pvert->z, size_max ) / size_max );
	}

	WORD* pIndices = pMesh->pIndices;
	_FACE*		pface	= &faces[0];

	for ( int fcount = 0; fcount < fSize; fcount++ )
	{
		*pIndices++ = pface->v1;
		*pIndices++ = pface->v3;
		*pIndices++ = pface->v2;
		pface++;
	}

	pMesh->iPrimitiveType	= D3DPT_TRIANGLELIST;
	pMesh->iDrawVertexCount	= pMesh->dwVertexCount;
	pMesh->iDrawPrimitives	= fSize;

	pFrame = pFrame->pChild;

	if ( pFrame )
		pMesh = pFrame->pMesh;

	SetNewObjectFinalProperties( obj, 0.0 );
	SetTexture( obj, 0 );

	return obj;
}

bool PROC_MAP::add_room()
{
	// get the number of sides that make up the new room (within the range)
	int		sides = ( rand() % ( room_max - room_min ) ) + room_min;

	// use same calc to find the edge size
	int		edge_size = ( rand() % ( size_max - size_min ) ) + size_min;

	// setup an array to store the temp room verts
	_VERT*	v = new _VERT[sides+1];	// extra vert for centre of the room
	_EDGE*	curr_edge;

	// find an outer edge to attach the room to
	do {
		curr_edge = &edges[ ( rand() % (int)edges.size() ) ];
	} while ( curr_edge->type != PM_COUTER && curr_edge->type != PM_ROUTER );

	// get vert ID's for the original edge
	int		v1 = curr_edge->v1, v2 = curr_edge->v2;

	// get coords of original edge (using reverse direction)
	v[0].x = verts[v2].x;
	v[0].y = verts[v2].z;
	v[1].x = verts[v1].x;
	v[1].y = verts[v1].z;

	// define the starting angle and the step angle
	float	curr_angle = atan2( v[1].y - v[0].y, v[1].x - v[0].x );
	float	diff_angle = Deg2Rad( 360.0f / sides );

	// store edges angle in z
	v[1].z = curr_angle;

	int		loop;

	// store new verts for room
	for ( loop = 2; loop < sides; loop++ )
	{
		curr_angle = curr_angle + diff_angle;

		v[loop].x = v[loop-1].x + cos( curr_angle ) * edge_size;
		v[loop].y = v[loop-1].y + sin( curr_angle ) * edge_size;

		v[loop].z = curr_angle;
	}

	// now calc the centre of the room for the last vert
	vvv_circle( v[0].x, v[0].y, 
				v[1].x, v[1].y, 
				v[2].x, v[2].y, 
				&v[sides].x, &v[sides].y );

	float	x, y, inner_angle, z;

	// check new edges (not the last one though yet)
	for ( loop = 1; loop < sides - 1; loop++ )
	{
		// nudge the beginning coords a tad
		x = v[loop].x + cos( v[loop+1].z ) * 0.5f;
		y = v[loop].y + sin( v[loop+1].z ) * 0.5f;

		// if edge collides with map then exit
		if ( edge_intersect( x, y, v[loop+1].x, v[loop+1].y ) )
		{
			delete[] v;
			return 0;
		}
	}

	// now check all inner edges (using the centre coord of the room)
	for ( loop = 0; loop < sides; loop++ )
	{
		// get angle of current inner edge
		inner_angle = atan2( v[sides].y - v[loop].y, v[sides].x - v[loop].x );

		// nudge the start coords a little
		x = v[loop].x + cos( inner_angle ) * 0.5f;
		y = v[loop].y + sin( inner_angle ) * 0.5f;

		// if the edge collides with the map then exit
		if ( edge_intersect( x, y, v[sides].x, v[sides].y ) )
		{
			delete[] v;
			return 0;
		}
	}

	// now check the last outer edge of the room
	inner_angle = atan2( v[sides-1].y - v[0].y, v[sides-1].x - v[0].x );
	x = v[0].x + cos( inner_angle ) * 0.5f;
	y = v[0].y + sin( inner_angle ) * 0.5f;

	// if collides with map then just exit
	if ( edge_intersect( x, y, v[sides-1].x, v[sides-1].y ) )
	{
		delete[] v;
		return 0;
	}

	// Now it is safe to add the room to the main map
	int		vsize = (int)verts.size();
	int		esize = (int)edges.size();
	int		fsize = (int)faces.size();

	// change current edge to an inner edge
	curr_edge->type = PM_CINNER;

	// add centre of rooms coordinate
	x = v[sides].x;
	y = v[sides].y;
	verts.push_back( _VERT( x, get_noise(x,y), y ) ); 

	// add first face ( current edge with centre of room )
	faces.push_back( _FACE( curr_edge->v2, curr_edge->v1, vsize, PM_RFACE ) );

	// now add the new edges to the list
	edges.push_back( _EDGE( curr_edge->v1, vsize, PM_RINNER ) );
	edges.push_back( _EDGE( curr_edge->v2, vsize, PM_RINNER ) );

	// vsize refers to centre room vert as well

	// this is used to record the last vert used in the next loop
	int		last_vert = curr_edge->v1;
	
	// now add the rest of the verts, edges and faces
	for ( loop = 2; loop < sides; loop++ )
	{
		x = v[loop].x;
		z = v[loop].y;
		y = get_noise( x, z );

		// add the new vert
		verts.push_back( _VERT( x, y, z ) );

		// add the face
		faces.push_back( _FACE( vsize, last_vert, vsize + loop - 1, PM_RFACE ) );

		// add the edges
		edges.push_back( _EDGE( last_vert, vsize, PM_RINNER ) );
		edges.push_back( _EDGE( last_vert, vsize + loop - 1, PM_ROUTER ) );

		// update last_vert
		last_vert = vsize + loop - 1;
	}

	delete[] v;

	return 1;	// 1 means success / 0 means failed
}

class PROC_MAP {
public:
	PROC_MAP(void);
	~PROC_MAP(void);

public:
	void	setup(int size, int seed, int lmin, int lmax, int amin, int amax);
	void	generate();

private:
	vector<_VERT>	verts;		// main verts list
	vector<_EDGE>	edges;		// main edges list
	vector<_FACE>	faces;		// main faces list

	

	int		map_size;			// ammount of corridors and rooms that make the map
	int		map_seed;

	int		size_min, size_max;	// corridor length min and max range
	int		ang_min, ang_max;	// corridor angle range
	int		cseg_min, cseg_max;	// corridor segment range

	int		room_min, room_max;	// number of edges to make a room

	PerlinNoise pn;				// used to slope the dungeon
	int		noise_hgt;			// height adjusted by perlin noise

	int		ObjID_Floor;

private:
	void	start_poly();

	_EDGE*	add_corridor_seg( _EDGE* edge );
	bool	add_room();

	bool	edge_intersect(float x1, float z1, float x2, float z2);
	bool	line_intersect(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);

	int		make_floor();
	float	get_noise(float x, float y);

	inline	int free_object() { int c=1; while (dbObjectExist(c)) c++; return c; }

	void	vvv_circle(	float px, float py,
						float qx, float qy,
						float rx, float ry,
						float *x, float *y); //, float &r );
};

void PROC_MAP::vvv_circle(	float px, float py,
							float qx, float qy,
							float rx, float ry,
							float *x, float *y) //, float &r )
{
	float p1  = ( qx + px ) / 2.0f;
	float y11 = ( qy + py ) / 2.0f;
	float yd1 = qx - px;
	float pd1 = -( qy - py );

	float p2  = ( rx + qx ) / 2.0f;
	float y2  = ( ry + qy ) / 2.0f;
	float yd2 = rx - qx;
	float pd2 = -( ry - qy );

	float ox = ( y11 * pd1 * pd2 + p2 * pd1 * yd2 - p1 * yd1 * pd2 - y2 * pd1 * pd2 ) / ( pd1 * yd2 - yd1 * pd2 );
	float oy = ( ox - p1 ) * yd1 / pd1 + y11;

	float dx = ox - px;
	float yd = oy - py;

	//r = sqrt( dx * dx + yd * yd );
	*x = ox;
	*y = oy;
}

void PROC_MAP::tessellate(int levels)
{
	while ( levels ) {
		// go through every face and tessellate it
		// it will also keep a temp record of the edges split and the new vert for the mid point

		int size = edges.size();
		int esize = size;		// original size of the temp edges list

		_temp_edge_list *edge_list = new _temp_edge_list[ size ];

		int v1, v2;
		float temp_vert_x, temp_vert_y, temp_vert_z;

		int vpos = verts.size(); // this is the new vert position

		while ( size ) {
			size--;

			v1 = edges[ size ].v1;
			v2 = edges[ size ].v2;

			// get the midpoint
			temp_vert_x = ( verts[ v1 ].x + verts[ v2 ].x ) / 2.0f;
			temp_vert_z = ( verts[ v1 ].z + verts[ v2 ].z ) / 2.0f;

			// get new noise height for the y coord
			temp_vert_y = get_noise(temp_vert_x, temp_vert_z);

			// store the new vert now
			verts.push_back( _VERT(temp_vert_x, temp_vert_y, temp_vert_z) );

			// change the current edges second vert
			edges[ size ].v2 = vpos;

			// add new edge
			edges.push_back( _EDGE(vpos, v2, edges[ size ].type, edges[ size ].segment) );
			//edges.push_back( _EDGE(vpos, v2, 0, edges[ size ].segment) );

			// add the details of the original edge to the struct
			edge_list[ size ].v1 = v1;
			edge_list[ size ].v2 = v2;
			edge_list[ size ].mid_vert = vpos;

			// increment the vpos for the next vert position mid point
			vpos++;
		}

		// now re-create the faces list
		size = faces.size();

		int v3, edge1, edge2, edge3;
		int mid1, mid2, mid3;
		int type, segment, etype;

		while ( size ) {
			size--;

			// store the faces original vertex indices for adding the new faces later
			v1 = faces[ size ].v1;
			v2 = faces[ size ].v2;
			v3 = faces[ size ].v3;

			// and the type and segment info
			type = faces[ size ].type;
			segment = faces[ size ].segment;

			// problem here:
			// I've stored the vertex index for the face instead of the edge index
			// so I'll have to find the original edge that matches both vertex indices
			// Luckily enough I've stored the info in the temp_edges list
			edge1 = find_temp_edge(v1, v2, edge_list, esize);
			edge2 = find_temp_edge(v2, v3, edge_list, esize);
			edge3 = find_temp_edge(v3, v1, edge_list, esize);

			mid1 = edge_list[ edge1 ].mid_vert;
			mid2 = edge_list[ edge2 ].mid_vert;
			mid3 = edge_list[ edge3 ].mid_vert;

			// alter original face first to new midpoints
			faces[ size ].v2 = mid1;
			faces[ size ].v3 = mid3;

			// now add the new faces
			faces.push_back( _FACE(mid1, v2, mid2, type, segment) );
			faces.push_back( _FACE(mid3, mid2, v3, type, segment) );
			faces.push_back( _FACE(mid1, mid2, mid3, type, segment) ); // centre face

			// set new new edges type for inner edges
			if ( type == PM_CFACE ) etype = PM_CINNER;
			else etype = PM_RINNER;

			// now add the centre faces edges to the edge_list
			edges.push_back( _EDGE(mid1, mid2, etype, segment) );
			edges.push_back( _EDGE(mid2, mid3, etype, segment) );
			edges.push_back( _EDGE(mid3, mid1, etype, segment) );
		}

		// remove the temp edge list
		delete[] edge_list;

		levels--;
	} // eof while ( levels )
}

int PROC_MAP::find_temp_edge(int v1, int v2, _temp_edge_list *list, int size)
{
	int pos = 0;
	while ( pos < size ) {
		
		if ( v1 == list->v1 && v2 == list->v2 ) return pos;
		if ( v1 == list->v2 && v2 == list->v1 ) return pos;	// double checking

		pos++;
		list++;
	}
	return 0;	// It really should not get to this point
}