#include "defines.h"
#include "globals.h"
#include "intrin.h"
#include "city.h"

float g_fBlocksX[ 24 ];
float g_fBlocksY[ 24 ];
int g_iStreetCountX;
float g_fStreetX[ 24 ];
int g_iStreetCountY;
float g_fStreetY[ 24 ];

void GenerateMap()
{
	g_iStreetCountX= 0;
	float fMinStep= 17.0f;
	float fMinStreet= 6.0f;
	float fMaxStreet= 16.0f;
	{
		float fPosX[ 2 ];
		fPosX[ 0 ]= fMinStep / 2.0f;
		fPosX[ 1 ]= -fMinStep / 2.0f;
		int iWait[ 2 ];
		iWait[ 0 ] = 0; 
		iWait[ 1 ] = 0;
		
		for( int i= 0; i < 12; ++i )
		{
			g_fBlocksX[ 12 + i ]= fPosX[ 0 ];
			g_fBlocksX[ 11 - i ]= fPosX[ 1 ];
			fPosX[ 0 ]+= fMinStep;
			fPosX[ 1 ]-= fMinStep;
			iWait[ 0 ]--;
			iWait[ 1 ]--;
			if( iWait[ 0 ] < 0 )
			{
				fPosX[ 0 ]+= g_Random.genFloat( fMinStreet, fMaxStreet );
				iWait[ 0 ]= g_Random.genInteger( 1, 3 );
				g_fStreetX[ g_iStreetCountX ]= ( g_fBlocksX[ 12 + i ] + fPosX[ 0 ] ) / 2.0f;
				g_iStreetCountX++;
			}
			if( iWait[ 1 ] < 0 )
			{
				fPosX[ 1 ]-= g_Random.genFloat( fMinStreet, fMaxStreet );
				iWait[ 1 ]= g_Random.genInteger( 1, 3 );
				g_fStreetX[ g_iStreetCountX ]= ( g_fBlocksX[ 11 - i ] + fPosX[ 1 ] ) / 2.0f;
				g_iStreetCountX++;
			}
		}
	}

	g_iStreetCountY= 0;
	{
		float fPosY[ 2 ];
		fPosY[ 0 ]= fMinStep / 2.0f;
		fPosY[ 1 ]= -fMinStep / 2.0f;
		for( int i= 0; i < 12; ++i )
		{
			g_fBlocksY[ 12 + i ]= fPosY[ 0 ];
			g_fBlocksY[ 11 - i ]= fPosY[ 1 ];
			fPosY[ 0 ]+= fMinStep;
			fPosY[ 1 ]-= fMinStep;
			if( i % 2 == 0 )
			{
				fPosY[ 0 ]+= g_Random.genFloat( fMinStreet, fMaxStreet );
				fPosY[ 1 ]-= g_Random.genFloat( fMinStreet, fMaxStreet );
				g_fStreetY[ g_iStreetCountY ]= ( g_fBlocksY[ 12 + i ] + fPosY[ 0 ] ) / 2.0f;
				g_iStreetCountY++;
				g_fStreetY[ g_iStreetCountY ]= ( g_fBlocksY[ 11 - i ] + fPosY[ 1 ] ) / 2.0f;
				g_iStreetCountY++;
			}
		}
	}
}


void CreateAllBuildings()
{
	g_Random.setSeed( 5 );
	GenerateMap();

	int iIndex= OI_BuildingFirst;
	int iBuilding= 0;
	bool bUnlock= false;
	for( int iX= 0; iX < 24; ++iX )
	{
		for( int iY= 0; iY < 24; ++iY )
		{
			float fY= g_fBlocksY[ iY ];
			float fX= g_fBlocksX[ iX ];
			float fHeight= GetCityHeight( fX, fY );
			if( fHeight <= 0.0f )
			{
				continue;
			}
			if( iBuilding % 5 == 0 )
			{
				if( bUnlock )
				{
					g_pEditObject->Unlock();
				}
				g_pEditObject= g_Objects + iIndex;
				assert( iIndex <= OI_BuildingLast );
				g_pEditObject->Create( 24 * 1000, 36 * 1000 );
				g_pEditObject->m_iUsedPreShader= PreDepth;
				g_pEditObject->m_iUsedShader[0]= Wall;
				g_pEditObject->Lock();
				bUnlock= true;
				iIndex++;
			}

			iBuilding++;
			if( g_Random.genInteger( 0, 5 ) == 0 )
			{
				CreateBuilding00( D3DXVECTOR3( fX, 0.0f, fY), fHeight * 1.0f );
			}
			else
			{
				CreateBuilding01( D3DXVECTOR3( fX, 0.0f, fY), fHeight * 1.0f );
			}

		}
	}

	if( bUnlock )
	{
		g_pEditObject->Unlock();
	}

}

float GetCityHeight( float fX, float fY )
{
	if( fabs( fX ) + fabs( fY ) < 32.0f )
	{
		return -1.0f;
	}
	float fBase= 2048.0f / sqrt( 2.5f * fX * fX + fY * fY ) - 10.0f;
	fBase-= 2.0f * ( cos( fX / 23.7f + 4.6f * cos( fY / 97.3f ) ) + cos( fY / 27.7f + 2.1f * cos( fX / 43.0f ) ) );

	return fBase;
}

void CreateSlicesX( const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot, 
					DWORD dwColor,
					int Slices, int SliceMode, float fSliceFac )
{
	if( Slices > -1 )
	{
		int iSliceCount= Slices;
		float fSliceSize= 2.0f * fSliceFac * vecExtent.x / (float)( Slices + 1 );
		float fSliceApart= ( vecExtent.x * 2.0f - fSliceSize ) / (float)( Slices + 1 );
		float fSliceStart= - vecExtent.x + fSliceSize * 0.5f;
		
		int iStart= ( SliceMode & 1 ) ? 0 : 1;
		int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );

		for( int i= iStart; i <= iEnd; ++i )
		{
			D3DXVECTOR3 v( fSliceStart + (float)i * fSliceApart, 0.0f, 0.0f );

			D3DXMATRIX m1;
			D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );

			D3DXVec3TransformCoord( &v, &v, &m1 );

			g_pEditObject->AddBox( 
				D3DXVECTOR3( vecCenter + v ),
				D3DXVECTOR3( fSliceSize * 0.5f, vecExtent.y, vecExtent.z),
				D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
				dwColor);
		}
	}
}

void CreateSlicesY( const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot, 
					DWORD dwColor,
					int Slices, int SliceMode, float fSliceFac )
{
	if( Slices > -1 )
	{
		int iSliceCount= Slices;
		float fSliceSize= 2.0f * fSliceFac * vecExtent.y / (float)( Slices + 1 );
		float fSliceApart= ( vecExtent.y * 2.0f - fSliceSize ) / (float)( Slices + 1 );
		float fSliceStart= - vecExtent.y + fSliceSize * 0.5f;
		
		int iStart= ( SliceMode & 1 ) ? 0 : 1;
		int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );

		for( int i= iStart; i <= iEnd; ++i )
		{
			D3DXVECTOR3 v( 0.0f, fSliceStart + (float)i * fSliceApart, 0.0f );

			D3DXMATRIX m1;
			D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );

			D3DXVec3TransformCoord( &v, &v, &m1 );

			g_pEditObject->AddBox( 
				D3DXVECTOR3( vecCenter + v ),
				D3DXVECTOR3( vecExtent.x, fSliceSize * 0.5f, vecExtent.z),
				D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
				dwColor);
		}
	}
}

void CreateSlicesZ( const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot, 
					DWORD dwColor,
					int Slices, int SliceMode, float fSliceFac )
{
	if( Slices > -1 )
	{
		int iSliceCount= Slices;
		float fSliceSize= 2.0f * fSliceFac * vecExtent.z / (float)( Slices + 1 );
		float fSliceApart= ( vecExtent.z * 2.0f - fSliceSize ) / (float)( Slices + 1 );
		float fSliceStart= -vecExtent.z + fSliceSize * 0.5f;
		
		int iStart= ( SliceMode & 1 ) ? 0 : 1;
		int iEnd= iSliceCount + ( ( SliceMode & 2 ) ? 1 : 0 );

		for( int i= iStart; i <= iEnd; ++i )
		{
			D3DXVECTOR3 v( 0.0f, 0.0f, fSliceStart + (float)i * fSliceApart );

			D3DXMATRIX m1;
			D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );

			D3DXVec3TransformCoord( &v, &v, &m1 );

			g_pEditObject->AddBox( 
				D3DXVECTOR3( vecCenter + v ),
				D3DXVECTOR3( vecExtent.x, vecExtent.y, fSliceSize * 0.5f),
				D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z),
				dwColor);
		}
	}
}

void CreateRoof(	const D3DXVECTOR3& vecCenter, 
				const D3DXVECTOR3& vecExtent, 
				const D3DXVECTOR3& vecRot,
				DWORD dwColor,
				int Type,
				float fParams[ 4 ] )
{
	if( Type == 0 )
	{
		float fHeight= 0.25f + fParams[ 0 ] * 0.25f;
		float fSub= 0.25f + fParams[ 1 ] * 0.25f;

		g_pEditObject->AddBox( 
			D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
			D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
			D3DXVECTOR3( vecRot.x, vecRot.y, vecRot.z ),
			dwColor);
	}
	if( Type == 1 )
	{
		float fHeight= 0.05f + fParams[ 0 ] * 0.1f;
		float fFrac= 0.05f + fParams[ 1 ] * 0.1f;
		float fSub= 0.0f;

		CreateSlicesX( 
			D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
			D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
			vecRot,
			dwColor,
			0, 3, fFrac );
		CreateSlicesZ( 
			D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
			D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
			vecRot,
			dwColor,
			0, 3, fFrac );

	}
	if( Type == 2 )
	{
		float fHeight= 0.25f + fParams[ 0 ] * 0.25f;
		float fFrac= 0.05f + fParams[ 1 ] * 0.025f;
		float fSub= 0.5f + fParams[ 2 ] * 0.5f;

		CreateSlicesX( 
			D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
			D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
			vecRot,
			dwColor,
			0, 3, fFrac );
		CreateSlicesZ( 
			D3DXVECTOR3( vecCenter.x, vecCenter.y + 2.0f * vecExtent.y + fHeight, vecCenter.z ),
			D3DXVECTOR3( vecExtent.x - fSub, fHeight, vecExtent.z - fSub),
			vecRot,
			dwColor,
			0, 3, fFrac );

	}
}

void CreateTower(	const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot,
					DWORD dwColor,
					float fInner1X, float fInner2X, float fInner1Z, float fInner2Z,
					int SlicesX, int SlicesZ, int SlicesY,
					float fSliceFacX, float fSliceFacZ, float fSliceFacY )
{
	g_pEditObject->AddBox( 
		D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
		D3DXVECTOR3( vecExtent.x - fInner2X, vecExtent.y, vecExtent.z - fInner2Z),
		vecRot,
		dwColor);

	CreateSlicesX( 
		D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
		D3DXVECTOR3( vecExtent.x - fInner2X, vecExtent.y, vecExtent.z - fInner1Z),
		vecRot,
		dwColor,
		SlicesX, 0, fSliceFacX );
	CreateSlicesZ( 
		D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y, vecCenter.z),
		D3DXVECTOR3( vecExtent.x - fInner1X, vecExtent.y, vecExtent.z - fInner2Z ),
		vecRot,
		dwColor,
		SlicesZ, 0, fSliceFacZ );
	CreateSlicesY( 
		D3DXVECTOR3( vecCenter.x, vecCenter.y + vecExtent.y + 1.0f / 64.0f , vecCenter.z),
		D3DXVECTOR3( vecExtent.x, vecExtent.y, vecExtent.z),
		vecRot,
		dwColor,
		SlicesY, 2, fSliceFacY );
}

void CreateAdd(		const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot,
					DWORD dwColor )
{
}

void MakeRoundPoint( float fAngle, float fHeightFac, D3DXVECTOR3& v, float MainSize[ 3 ], float fReduce )
{
	v.x= -sin( fAngle ) * ( MainSize[ 0 ] - fReduce );
	v.y= fHeightFac * MainSize[ 2 ];
	v.z= cos( fAngle ) * ( MainSize[ 1 ] - fReduce );
}

void CreateBuilding00( const D3DXVECTOR3& vecPos, float fAddHeight )
{
	float fHeight= g_Random.genFloat();
	fHeight= fHeight * fHeight * 12.0f + 10.0f + fAddHeight;
	int iStories= (int)( fHeight / 2.6f );
	float fStoryFrac= g_Random.genFloat( 2.0f / 64.0f, 5.0f / 64.0f ) / (float)iStories;

	const float fMaxSize= 8.0f;
	float MainSize[ 3 ]= { fMaxSize, fMaxSize, fHeight };
	MainSize[ g_Random.genInteger( 0, 1 ) ]= fMaxSize * g_Random.genFloat( 0.66f, 1.0f );

	int iWindowCount= g_Random.genInteger( 16, 28 );

	float fWindowPart= g_Random.genFloat( 0.125f, 0.1875f );
	float fWindowDepth[ 2 ]= 
	{	
		g_Random.genFloat( 0.0625f, 0.125f ),
		g_Random.genFloat( 0.375f, 0.5f )
	};

	if( g_Random.genInteger( 0, 1 ) == 1 )
	{
		fWindowPart= 1.0f - fWindowPart;
	}

	for( int i= 0; i < iWindowCount; ++i )
	{
		float fAngle[ 3 ]=
		{
			(float)i / (float)iWindowCount * c_2PI,
			0.0f,
			(float)(i + 1 )/ (float)iWindowCount * c_2PI
		};
		fAngle[ 1 ] = fAngle[ 0 ] * fWindowPart + fAngle[ 2 ] * ( 1.0f - fWindowPart );
		float fHeightFac[ 2 ]= { 0.0f, 1.0f };

		float fReduce= fWindowDepth[ 0 ];
		for( int j= 0; j < 2; ++j )
		{
			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle[ j ], fHeightFac[ 0 ], v1, MainSize, fReduce );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle[ j ], fHeightFac[ 1 ], v2, MainSize, fReduce );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v3, MainSize, fReduce );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v4, MainSize, fReduce );

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}

			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v1, MainSize, fReduce );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v2, MainSize, fReduce );
				fReduce= fabs( fReduce - fWindowDepth[ 1 ] );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 0 ], v3, MainSize, fReduce );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle[ j + 1], fHeightFac[ 1 ], v4, MainSize, fReduce );

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}
		}
	}

	float fAngleOffset= 0.0f; 
	if( fWindowPart < 0.5f )
	{
		fAngleOffset= fWindowPart / (float)iWindowCount * c_PI;
	}
	else
	{
		fAngleOffset= ( - 1.0f + fWindowPart ) / (float)iWindowCount * c_PI;
	}

	float fAngleStep= 1.0f / (float)iWindowCount * c_2PI;
	float fReduce= g_Random.genFloat( -0.125f, 0.0625f );
	float fReduceInner= 1.0f;
	for( int iStory= 0; iStory < iStories; ++iStory )
	{
		float fHeightFac= (float)(iStory) / (float)iStories;

		for( int i= 0; i < iWindowCount; ++i )
		{
			float fAngle= (float)i * fAngleStep - fAngleOffset;
			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v1, MainSize, fReduce );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v2, MainSize, fReduce );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v3, MainSize, fReduce );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v4, MainSize, fReduce );

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}
			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v1, MainSize, fReduceInner );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle, fHeightFac - fStoryFrac, v2, MainSize, fReduce );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v3, MainSize, fReduceInner );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac - fStoryFrac, v4, MainSize, fReduce );

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}
			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v1, MainSize, fReduce );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle, fHeightFac + fStoryFrac, v2, MainSize, fReduceInner );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v3, MainSize, fReduce );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle + fAngleStep, fHeightFac + fStoryFrac, v4, MainSize, fReduceInner );

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}
		}
	}

	float fRoofBorderHeight= g_Random.genFloat( 0.5f, 1.0f );
	float fRoofBorderWidth= g_Random.genFloat( 0.8f, 0.9f );

	float fRoofHeights[ 24 ];
	float fRoofSize[ 24 ];
	int iRoofCount= 0;
	fRoofHeights[ iRoofCount ]= fHeight;
	fRoofSize[ iRoofCount ]= 0.75f;
	iRoofCount++;
	fRoofHeights[ iRoofCount ]= fHeight;
	fRoofSize[ iRoofCount ]= 1.0f;
	iRoofCount++;
	fHeight+= fRoofBorderHeight;
	fRoofHeights[ iRoofCount ]= fHeight;
	fRoofSize[ iRoofCount ]= 1.0f;
	iRoofCount++;

	if( g_Random.genInteger( 0, 1 ) == 0 )
	{
		fRoofHeights[ iRoofCount ]= fHeight;
		fRoofSize[ iRoofCount ]= fRoofBorderWidth;
		iRoofCount++;
		fHeight-= fRoofBorderHeight * g_Random.genFloat( 0.1f, 0.5f );
		fRoofHeights[ iRoofCount ]= fHeight;
		fRoofSize[ iRoofCount ]= fRoofBorderWidth;
		iRoofCount++;
	}

	fRoofHeights[ iRoofCount ]= fHeight;
	fRoofSize[ iRoofCount ]= 0.0f;
	iRoofCount++;

	for( int Roof= 1; Roof < iRoofCount; ++Roof )
	{
		for( int i= 0; i < iWindowCount; ++i )
		{
			float fAngle= (float)i * fAngleStep - fAngleOffset;
			{
				D3DXVECTOR3 v1;
				MakeRoundPoint( fAngle, 0.0f, v1, MainSize, 0.0f );
				D3DXVECTOR3 v2;
				MakeRoundPoint( fAngle, 0.0f, v2, MainSize, 0.0f );
				D3DXVECTOR3 v3;
				MakeRoundPoint( fAngle + fAngleStep, 0.0f, v3, MainSize, 0.0f );
				D3DXVECTOR3 v4;
				MakeRoundPoint( fAngle + fAngleStep, 0.0f, v4, MainSize, 0.0f );
				v1*= fRoofSize[ Roof -1];
				v1.y= fRoofHeights[ Roof -1];
				v2*= fRoofSize[ Roof ];
				v2.y= fRoofHeights[ Roof ];
				v3*= fRoofSize[ Roof -1];
				v3.y= fRoofHeights[ Roof -1];
				v4*= fRoofSize[ Roof ];
				v4.y= fRoofHeights[ Roof ];

				g_pEditObject->AddQuadFlat(
					v1 + vecPos,
					v2 + vecPos,
					v3 + vecPos,
					v4 + vecPos,
					0xffc0c0c0 );
			}
		}
	}
}

void CreateBuilding01( const D3DXVECTOR3& vecPos, float fAddHeight )
{
	float fHeight= g_Random.genFloat();
	fHeight= fHeight * fHeight * 12.0f + 10.0f + fAddHeight;
	int iStories= (int)( fHeight / 2.6f );
	float fStoryFrac= g_Random.genFloat( 2.0f / 64.0f, 5.0f / 64.0f );

	int iXZMode= g_Random.genInteger( 0, 1 );

	const float fMaxSize= 8.0f;
	float MainSize[2]= {fMaxSize, fMaxSize }; 

	MainSize[ iXZMode ]-= g_Random.genFloat( 1.5f, 4.0f );
	MainSize[ 1 - iXZMode ]-= g_Random.genFloat( 0.5f, 1.75f );

	int iRoofType= g_Random.genInteger( -2, 2 );
	float fRoofParam[ 4 ]= 
	{
		g_Random.genFloat(),
		g_Random.genFloat(),
		g_Random.genFloat(),
		g_Random.genFloat(),
	};

	float fInner[ 4 ]= 
	{
		g_Random.genFloat( 0.125f, 0.5f ),
		g_Random.genFloat( 0.375f, 0.875f ),
		g_Random.genFloat( 0.125f, 0.5f ),
		g_Random.genFloat( 0.375f, 0.875f ),
	};
	fInner[ iXZMode * 2 ]*= 0.625f;
	fInner[ iXZMode * 2 + 1 ]*= 0.625f;

	if( g_Random.genInteger( 0, 4 ) == 4 )
	{
		fInner[ 2 - iXZMode * 2 ]*= -1.0f;
	}

	int iWindowSlices[ 2 ]=
	{ -1, -1 };

	for( int i= 0; i < 2; ++i )
	{
		int iSliceMode= g_Random.genInteger( 0, 6 );
		if( iSliceMode > 1 )
		{
			iWindowSlices[ i ]= (int)MainSize[ i ] - g_Random.genInteger( 0, 3 );
		}
		else if( iSliceMode == 1 )
		{
			iWindowSlices[ i ]= g_Random.genInteger( 1, 2 );
		}
	}
		
	int iModes[ 20 ]= 
	{ 
		0, 0,
		0, 0,
		1, 0,
		0, 1,
		0, 2,
		2, 0,
		2, 2,
		2, 2,
		2, 1,
		1, 2,
	};
	int iTowerMode= g_Random.genInteger( 0, 9 ) * 2;

	if( iModes[ iTowerMode ] == 1 || iModes[ iTowerMode + 1 ] == 1 )
	{
		if( g_Random.genInteger( 0, 1 ) == 1 )
		{
			fInner[ iXZMode * 2 ]*= -1.0f;
		}
		
		MainSize[ 1 - iXZMode ]= fMaxSize - g_Random.genFloat( 1.5f, 2.5f );
	}

	
	for( int i= 0; i < 2; ++i )
	{
		int iCurMode= iModes[ iTowerMode + i ];
		
		if( iCurMode == 1 )
		{
			float fSize= g_Random.genFloat( fMaxSize * 0.375f, fMaxSize * 0.625f );
			float fInner[ 4 ]= 
			{
				g_Random.genFloat( 0.125f, 0.5f ),
				g_Random.genFloat( 0.375f, 0.875f ),
				g_Random.genFloat( 0.125f, 0.5f ),
				g_Random.genFloat( 0.375f, 0.875f ),
			};

			int iWindowSlice= (int)fSize - g_Random.genInteger( 0, 2 );

			float fOffset[ 2 ]=
			{	
				( fMaxSize - fSize ),
				( fMaxSize - fSize )
			};

			if( i == 1 )
			{
				fOffset[ iXZMode ]*= -1.0f;
			}

			if( g_Random.genInteger( 0, 1 ) == 1 )
			{
				fOffset[ 1 - iXZMode ]*= -1.0f;
			}

			CreateTower( 
				D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
				D3DXVECTOR3( fSize, fHeight * 0.5f, fSize ),
				D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
				0xffc0c0c0,
				fInner[ 0 ], fInner[ 1 ], fInner[ 2 ], fInner[ 3 ],
				iWindowSlice, iWindowSlice, iStories,
				g_Random.genFloat( 0.125f, 0.875f ), 
				g_Random.genFloat( 0.125f, 0.875f ), 
				fStoryFrac );
			
			if( iRoofType == 0 )
			{
				CreateRoof(
					D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
					D3DXVECTOR3( fSize, fHeight * 0.5f, fSize ),
					D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
					0xffc0c0c0,
					iRoofType,
					fRoofParam );
			}
		}

		if( iCurMode == 2 )
		{
			float fSizeLeft= minimum( fMaxSize - MainSize[ 0 ], fMaxSize - MainSize[ 1 ] );

			float fAngle= 0.0f;

			float fInnerConfigs[ 6 ]=
			{
				0.0625f, 0.0625f,
				g_Random.genFloat( 0.0625f, 0.125f ), g_Random.genFloat( 0.25f, 0.5f ),
				g_Random.genFloat( -0.125f, -0.25f ), g_Random.genFloat( 0.125f, 0.25f ),
			};
			int SliceConfig[ 3 ]=
			{
				-1,
				2,
				g_Random.genInteger( 1, 3 ),
			};
			float fFracConfig[ 3 ]=
			{
				0.0f,
				g_Random.genFloat( 0.125f, 0.25f ),
				g_Random.genFloat( 0.25f, 0.5f ),
			};
			int ConfigX= g_Random.genInteger( 0, 2 );
			int ConfigZ= g_Random.genInteger( 0, 2 );

			float fOffset[ 2 ]=
			{	
				MainSize[ 0 ],
				MainSize[ 1 ],
			};


			if( fSizeLeft > 1.4f )
			{
				fAngle= c_PI / 4;

				fSizeLeft/= 1.5f;
			}
			else
			{
				float fAdd= g_Random.genFloat( 0.125f, 0.75f );
				fSizeLeft+= fAdd;
				fOffset[ 0 ]= minimum( fOffset[ 0 ], fMaxSize - fSizeLeft );
				fOffset[ 1 ]= minimum( fOffset[ 1 ], fMaxSize - fSizeLeft );
				if( g_Random.genInteger( 0, 1 ) == 1 )
				{
					fOffset[ 1 - iXZMode ]*= g_Random.genFloat( 0.0f, 0.6f );
				}

			}

			if( i == 1 )
			{
				fOffset[ iXZMode ]*= -1.0f;
			}
			if( g_Random.genInteger( 0, 1 ) == 1 )
			{
				fOffset[ 1 - iXZMode ]*= -1.0f;
			}

			CreateTower( 
				D3DXVECTOR3( vecPos.x + fOffset[ 0 ] , vecPos.y, vecPos.z + fOffset[ 1 ] ),
				D3DXVECTOR3( fSizeLeft, fHeight * 0.5f, fSizeLeft),
				D3DXVECTOR3( fAngle, 0.0f, 0.0f ),
				0xffc0c0c0,
				fInnerConfigs[ ConfigX * 2 ],fInnerConfigs[ ConfigX * 2 + 1 ], 
				fInnerConfigs[ ConfigZ * 2 ],fInnerConfigs[ ConfigZ * 2 + 1 ], 
				SliceConfig[ ConfigX ], SliceConfig[ ConfigZ ], iStories,
				fFracConfig[ ConfigX ], 
				fFracConfig[ ConfigZ ], 
				fStoryFrac );
		}
	}

	CreateTower( 
		D3DXVECTOR3( vecPos.x , vecPos.y , vecPos.z ),
		D3DXVECTOR3( MainSize[ 0 ], fHeight * 0.5f, MainSize[ 1 ]),
		D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
		0xffc0c0c0,
		fInner[ 0 ], fInner[ 1 ], fInner[ 2 ], fInner[ 3 ],
		iWindowSlices[ 0 ], iWindowSlices[ 1 ], iStories,
		g_Random.genFloat( 0.125f, 0.875f ), 
		g_Random.genFloat( 0.125f, 0.875f ), 
		fStoryFrac );
	CreateRoof(
		D3DXVECTOR3( vecPos.x , vecPos.y , vecPos.z ),
		D3DXVECTOR3( MainSize[ 0 ], fHeight * 0.5f, MainSize[ 1 ]),
		D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
		0xffc0c0c0,
		iRoofType,
		fRoofParam );
}