// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * 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 3 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, see  http://www.gnu.org/licenses/.

// terrain.cpp


#include <windows.h>
#include <stdio.h>
#include <d3d.h>

#include "common/struct.h"
#include "math/const.h"
#include "math/geometry.h"
#include "old/d3dengine.h"
#include "old/d3dmath.h"
#include "old/d3dutil.h"
#include "common/language.h"
#include "common/event.h"
#include "common/misc.h"
#include "common/iman.h"
#include "old/math3d.h"
#include "old/modfile.h"
#include "old/water.h"
#include "old/terrain.h"


const int BMPHEAD = 1078;



// Constructor of the terrain.

CTerrain::CTerrain(CInstanceManager* iMan)
{
	m_iMan = iMan;
	m_iMan->AddInstance(CLASS_TERRAIN, this);

	m_engine = (CD3DEngine*)m_iMan->SearchInstance(CLASS_ENGINE);
	m_water  = (CWater*)m_iMan->SearchInstance(CLASS_WATER);

	m_mosaic        = 20;
	m_brick         = 1<<4;
	m_size          = 10.0f;
	m_vision        = 200.0f;
	m_relief        = 0;
	m_texture       = 0;
	m_objRank       = 0;
	m_scaleMapping  = 0.01f;
	m_scaleRelief   = 1.0f;
	m_subdivMapping = 1;
	m_depth         = 2;
	m_texBaseName[0]= 0;
	m_texBaseExt[0] = 0;
	m_bMultiText    = true;
	m_bLevelText    = false;
	m_resources     = 0;
	m_levelMatTotal = 0;
	m_levelMatMax   = 0;
	m_levelDot      = 0;
	m_wind          = Math::Vector(0.0f, 0.0f, 0.0f);
	m_defHardness   = 0.5f;

	FlushBuildingLevel();
	FlushFlyingLimit();
}

// Destructor of the terrain.

CTerrain::~CTerrain()
{
	free(m_relief);
	free(m_texture);
	free(m_objRank);
	free(m_resources);
}


// Generates a new flat terrain.
// The terrain is composed of mosaics, themselves composed of bricks.
// Each brick is composed of two triangles.
// mosaic:       number of mosaics along the axes X and Z
// brick:        number of bricks (power of 2)
// size:         size of a brick along the axes X and Z
// vision:       vision before a change of resolution
// scaleMapping: scale textures for mapping
//
//              ^ z
//	        |   <--->  brick*size
//	+---+---+---+---+
//	|   |   |   |_|_|  mosaic = 4
//	|   |   |   | | |  brick  = 2 (brickP2=1)
//	+---+---+---+---+
//	|\ \|   |   |   |
//	|\ \|   |   |   |
//	+---+---o---+---+---> x
//	|   |   |   |   |
//	|   |   |   |   |
//	+---+---+---+---+  
//	|   |   |   |   |  The land is viewed from above here.
//	|   |   |   |   |
//	+---+---+---+---+
//      <--------------->  mosaic*brick*size

bool CTerrain::Generate(int mosaic, int brickP2, float size, float vision,
						int depth, float hardness)
{
	int		dim;

	m_mosaic        = mosaic;
	m_brick         = 1<<brickP2;
	m_size          = size;
	m_vision        = vision;
	m_depth         = depth;
	m_defHardness   = hardness;

	m_engine->SetTerrainVision(vision);

	m_bMultiText    = true;
	m_bLevelText    = false;
	m_scaleMapping  = 1.0f/(m_brick*m_size);
	m_subdivMapping = 1;

	dim = (m_mosaic*m_brick+1)*(m_mosaic*m_brick+1);
	m_relief = (float*)malloc(sizeof(float)*dim);
	ZeroMemory(m_relief, sizeof(float)*dim);

	dim = m_mosaic*m_subdivMapping*m_mosaic*m_subdivMapping;
	m_texture = (int*)malloc(sizeof(int)*dim);
	ZeroMemory(m_texture, sizeof(int)*dim);

	dim = m_mosaic*m_mosaic;
	m_objRank = (int*)malloc(sizeof(int)*dim);
	ZeroMemory(m_objRank, sizeof(int)*dim);

	return true;
}


int CTerrain::RetMosaic()
{
	return m_mosaic;
}

int CTerrain::RetBrick()
{
	return m_brick;
}

float CTerrain::RetSize()
{
	return m_size;
}

float CTerrain::RetScaleRelief()
{
	return m_scaleRelief;
}


// Initializes the names of textures to use for the land.

bool CTerrain::InitTextures(char* baseName, int* table, int dx, int dy)
{
	int		x, y;
	char*	p;

	m_bLevelText = false;

	strcpy(m_texBaseName, baseName);
	p = strchr(m_texBaseName, '.');  // p <- ^beginning of the extension
	if ( p == 0 )
	{
		strcpy(m_texBaseExt, ".tga");
	}
	else
	{
		strcpy(m_texBaseExt, p);  // m_texBaseExt <- ".tga" or ".bmp"
		*p = 0;                   // m_texBaseName <- name without extension
	}

	for ( y=0 ; y<m_mosaic*m_subdivMapping ; y++ )
	{
		for ( x=0 ; x<m_mosaic*m_subdivMapping ; x++ )
		{
			m_texture[x+y*m_mosaic] = table[(x%dx)+(y%dy)*dx];
		}
	}
	return true;
}


// Empties level.

void CTerrain::LevelFlush()
{
	m_levelMatTotal = 0;
	m_levelMatMax   = 0;
	m_levelID       = 1000;
	LevelCloseTable();
}

// Initializes the names of textures to use for the land.

bool CTerrain::LevelMaterial(int id, char* baseName, float u, float v,
							 int up, int right, int down, int left,
							 float hardness)
{
	int		i;

	i = m_levelMatTotal;
	if ( i >= MAXMATTERRAIN-1 )  return false;

	LevelOpenTable();

	if ( id == 0 )
	{
		id = m_levelID++;  // puts an ID internal standard
	}

	strcpy(m_levelMat[i].texName, baseName);
	m_levelMat[i].id     = id;
	m_levelMat[i].u      = u;
	m_levelMat[i].v      = v;
	m_levelMat[i].mat[0] = up;
	m_levelMat[i].mat[1] = right;
	m_levelMat[i].mat[2] = down;
	m_levelMat[i].mat[3] = left;
	m_levelMat[i].hardness = hardness;

	if ( m_levelMatMax < up+1    )  m_levelMatMax = up+1;
	if ( m_levelMatMax < right+1 )  m_levelMatMax = right+1;
	if ( m_levelMatMax < down+1  )  m_levelMatMax = down+1;
	if ( m_levelMatMax < left+1  )  m_levelMatMax = left+1;

	m_bLevelText = true;
	m_subdivMapping = 4;

	m_levelMatTotal ++;
	return true;
}


// Load relief from a BMP file.
// The size of the image must be dimension dx and dy with dx=dy=(mosaic*brick)+1.
// The image must be 8 bits/pixel, 256 colors with a standard pallet.

// Converts coordinated image (x;y) -> world (x;-;z) :
//	Wx =   5*Ix-400
//	Wz = -(5*Iy-400)

// Converts coordinated world (x;-;z) -> image (x;y) :
//	Ix = (400+Wx)/5
//	Iy = (400-Wz)/5

bool CTerrain::ResFromBMP(const char* filename)
{
	FILE*			file;
	int				size, sizem;

	file = fopen(filename, "rb");
	if ( file == NULL )  return false;

	size  = (m_mosaic*m_brick)+1;
	sizem = ((size+4-1)/4)*4;  // upper size multiple of 4

	if ( m_resources != 0 )
	{
		free(m_resources);
	}

	m_resources = (unsigned char*)malloc(BMPHEAD+sizem*size);
	fread(m_resources, BMPHEAD+sizem*size, 1, file);

	if ( m_resources[18] != (size&0xff) || m_resources[19] != (size>>8) ||
		 m_resources[22] != (size&0xff) || m_resources[23] != (size>>8) )
	{
		free(m_resources);
		m_resources = 0;
		fclose(file);
		return false;
	}

	fclose(file);
	return true;
}

// Returns the resource type available underground.

TerrainRes CTerrain::RetResource(const Math::Vector &p)
{
	int		x, y, size, sizem, ress;

	if ( m_resources == 0 )  return TR_NULL;

	x = (int)((p.x + (m_mosaic*m_brick*m_size)/2.0f)/m_size);
	y = (int)((p.z + (m_mosaic*m_brick*m_size)/2.0f)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return TR_NULL;

	size  = (m_mosaic*m_brick)+1;
	sizem = ((size+4-1)/4)*4;  // upper size multiple of 4

	ress = m_resources[BMPHEAD+x+sizem*y];
	if ( ress ==  5 )  return TR_STONE;    // red?
	if ( ress == 35 )  return TR_URANIUM;  // yellow?
	if ( ress == 30 )  return TR_POWER;    // green?
	if ( ress == 24 )  return TR_KEYa;     // ~green?
	if ( ress == 25 )  return TR_KEYb;     // ~green?
	if ( ress == 26 )  return TR_KEYc;     // ~green?
	if ( ress == 27 )  return TR_KEYd;     // ~green?

	return TR_NULL;
}


// Initializes a completely flat terrain.

void CTerrain::FlushRelief()
{
	free(m_relief);
	m_relief = 0;
}

// Load relief from a BMP file.
// The size of the image must be dimension dx and dy with dx=dy=(mosaic*brick)+1.
// The image must be 8 bits/pixel, 256 gray scale:
// white = ground (y=0)
// black = mountain (y=255*scaleRelief)

// Converts coordinated image(x;y) -> world (x;-;z) :
//	Wx =   5*Ix-400
//	Wz = -(5*Iy-400)

// Converts coordinated world (x;-;z) -> image (x;y) :
//	Ix = (400+Wx)/5
//	Iy = (400-Wz)/5

bool CTerrain::ReliefFromBMP(const char* filename, float scaleRelief,
							 bool adjustBorder)
{
	FILE*			file;
	unsigned char*	buffer;
	int				size, sizem, x, y;
	float			level, limit, dist, border;

	m_scaleRelief = scaleRelief;

	file = fopen(filename, "rb");
	if ( file == NULL )  return false;

	size  = (m_mosaic*m_brick)+1;
	sizem = ((size+4-1)/4)*4;  // upper size multiple of 4

	buffer = (unsigned char*)malloc(BMPHEAD+sizem*size);
	fread(buffer, BMPHEAD+sizem*size, 1, file);

	if ( buffer[18] != (size&0xff) || buffer[19] != (size>>8) ||
		 buffer[22] != (size&0xff) || buffer[23] != (size>>8) )
	{
		free(buffer);
		fclose(file);
		return false;
	}

	limit = 0.9f;
	for ( y=0 ; y<size ; y++ )
	{
		for ( x=0 ; x<size ; x++ )
		{
			level = (255-buffer[BMPHEAD+x+sizem*y])*scaleRelief;

//?			dist = Length((float)(x-size/2), (float)(y-size/2));
			dist = Math::Max(fabs((float)(x-size/2)), fabs((float)(y-size/2)));
			dist = dist/(float)(size/2);
			if ( dist > limit && adjustBorder )
			{
				dist = (dist-limit)/(1.0f-limit);  // 0..1
				if ( dist > 1.0f )  dist = 1.0f;
				border = 300.0f+Math::Rand()*20.0f;
				level = level+dist*(border-level);
			}

			m_relief[x+y*size] = level;
		}
	}

	free(buffer);
	fclose(file);
	return true;
}

// Adds a point of elevation in the buffer of relief.

bool CTerrain::ReliefAddDot(Math::Vector pos, float scaleRelief)
{
	float	dim;
	int		size, x, y;

	dim = (m_mosaic*m_brick*m_size)/2.0f;
	size = (m_mosaic*m_brick)+1;

	pos.x = (pos.x+dim)/m_size;
	pos.z = (pos.z+dim)/m_size;

	x = (int)pos.x;
	y = (int)pos.z;

	if ( x < 0 || x >= size ||
		 y < 0 || y >= size )  return false;

	if ( m_relief[x+y*size] < pos.y*scaleRelief )
	{
		m_relief[x+y*size] = pos.y*scaleRelief;
	}
	return true;
}

// Load relief from a DXF file.

bool CTerrain::ReliefFromDXF(const char* filename, float scaleRelief)
{
	FILE*		file = NULL;
	char		line[100];
	int			command, rankSommet, nbSommet, nbFace, size;
	Math::Vector*	table;
	bool		bWaitNbSommet;
	bool		bWaitNbFace;
	bool		bWaitSommetX;
	bool		bWaitSommetY;
	bool		bWaitSommetZ;
	bool		bWaitFaceX;
	bool		bWaitFaceY;
	bool		bWaitFaceZ;
	float		x,y,z;
	int			p1,p2,p3;

	ZeroMemory(m_relief, sizeof(float)*(m_mosaic*m_brick+1)*(m_mosaic*m_brick+1));

	file = fopen(filename, "r");
	if ( file == NULL )  return false;

	size  = (m_mosaic*m_brick)+1;
	table = (Math::Vector*)malloc(sizeof(Math::Vector)*size*size);

	rankSommet = 0;
	bWaitNbSommet = false;
	bWaitNbFace   = false;
	bWaitSommetX  = false;
	bWaitSommetY  = false;
	bWaitSommetZ  = false;
	bWaitFaceX    = false;
	bWaitFaceY    = false;
	bWaitFaceZ    = false;

	while ( fgets(line, 100, file) != NULL )
	{
		sscanf(line, "%d", &command);
		if ( fgets(line, 100, file) == NULL )  break;

		if ( command == 66 )
		{
			bWaitNbSommet = true;
		}

		if ( command == 71 && bWaitNbSommet )
		{
			bWaitNbSommet = false;
			sscanf(line, "%d", &nbSommet);
			if ( nbSommet > size*size )  nbSommet = size*size;
			rankSommet = 0;
			bWaitNbFace = true;
		}

		if ( command == 72 && bWaitNbFace )
		{
			bWaitNbFace = false;
			sscanf(line, "%d", &nbFace);
			bWaitSommetX = true;
		}

		if ( command == 10 && bWaitSommetX )
		{
			bWaitSommetX = false;
			sscanf(line, "%f", &x);
			bWaitSommetY = true;
		}

		if ( command == 20 && bWaitSommetY )
		{
			bWaitSommetY = false;
			sscanf(line, "%f", &y);
			bWaitSommetZ = true;
		}

		if ( command == 30 && bWaitSommetZ )
		{
			bWaitSommetZ = false;
			sscanf(line, "%f", &z);

			nbSommet --;
			if ( nbSommet >= 0 )
			{
				Math::Vector p(x,z,y);  // permutation of Y and Z!
				table[rankSommet++] = p;
				bWaitSommetX = true;
			}
			else
			{
				bWaitFaceX = true;
			}
		}

		if ( command == 71 && bWaitFaceX )
		{
			bWaitFaceX = false;
			sscanf(line, "%d", &p1);
			if ( p1 < 0 )  p1 = -p1;
			bWaitFaceY = true;
		}

		if ( command == 72 && bWaitFaceY )
		{
			bWaitFaceY = false;
			sscanf(line, "%d", &p2);
			if ( p2 < 0 )  p2 = -p2;
			bWaitFaceZ = true;
		}

		if ( command == 73 && bWaitFaceZ )
		{
			bWaitFaceZ = false;
			sscanf(line, "%d", &p3);
			if ( p3 < 0 )  p3 = -p3;

			nbFace --;
			if ( nbFace >= 0 )
			{
				ReliefAddDot(table[p3-1], scaleRelief);
				ReliefAddDot(table[p2-1], scaleRelief);
				ReliefAddDot(table[p1-1], scaleRelief);
				bWaitFaceX = true;
			}
		}

	}

	free(table);
	fclose(file);
	return true;
}


// Adjusts a position so that it does not exceed the boundaries.

void CTerrain::LimitPos(Math::Vector &pos)
{
	float		dim;

#if _TEEN
	dim = (m_mosaic*m_brick*m_size)/2.0f*0.98f;
#else
	dim = (m_mosaic*m_brick*m_size)/2.0f*0.92f;
#endif

	if ( pos.x < -dim )  pos.x = -dim;
	if ( pos.x >  dim )  pos.x =  dim;
	if ( pos.z < -dim )  pos.z = -dim;
	if ( pos.z >  dim )  pos.z =  dim;
}


// Adjust the edges of each mosaic to be compatible with all lower resolutions.

void CTerrain::AdjustRelief()
{
	int		x, y, xx, yy, ii, b;
	float	level1, level2;

	if ( m_depth == 1 )  return;

	ii = m_mosaic*m_brick+1;
	b = 1<<(m_depth-1);

	for ( y=0 ; y<m_mosaic*m_brick ; y+=b )
	{
		for ( x=0 ; x<m_mosaic*m_brick ; x+=b )
		{
			yy = 0;
			if ( (y+yy)%m_brick == 0 )
			{
				level1 = m_relief[(x+0)+(y+yy)*ii];
				level2 = m_relief[(x+b)+(y+yy)*ii];
				for ( xx=1 ; xx<b ; xx++ )
				{
					m_relief[(x+xx)+(y+yy)*ii] = ((level2-level1)/b)*xx+level1;
				}
			}

			yy = b;
			if ( (y+yy)%m_brick == 0 )
			{
				level1 = m_relief[(x+0)+(y+yy)*ii];
				level2 = m_relief[(x+b)+(y+yy)*ii];
				for ( xx=1 ; xx<b ; xx++ )
				{
					m_relief[(x+xx)+(y+yy)*ii] = ((level2-level1)/b)*xx+level1;
				}
			}

			xx = 0;
			if ( (x+xx)%m_brick == 0 )
			{
				level1 = m_relief[(x+xx)+(y+0)*ii];
				level2 = m_relief[(x+xx)+(y+b)*ii];
				for ( yy=1 ; yy<b ; yy++ )
				{
					m_relief[(x+xx)+(y+yy)*ii] = ((level2-level1)/b)*yy+level1;
				}
			}

			xx = b;
			if ( (x+xx)%m_brick == 0 )
			{
				level1 = m_relief[(x+xx)+(y+0)*ii];
				level2 = m_relief[(x+xx)+(y+b)*ii];
				for ( yy=1 ; yy<b ; yy++ )
				{
					m_relief[(x+xx)+(y+yy)*ii] = ((level2-level1)/b)*yy+level1;
				}
			}
		}
	}
}


// Calculates a vector of the terrain.

Math::Vector CTerrain::RetVector(int x, int y)
{
	Math::Vector	p;

	p.x = x*m_size - (m_mosaic*m_brick*m_size)/2;
	p.z = y*m_size - (m_mosaic*m_brick*m_size)/2;

	if ( m_relief != 0                   &&
		 x >= 0 && x <= m_mosaic*m_brick &&
		 y >= 0 && y <= m_mosaic*m_brick )
	{
		p.y = m_relief[x+y*(m_mosaic*m_brick+1)];
	}
	else
	{
		p.y = 0.0f;
	}

	return p;
}

// Calculates a vertex of the terrain.
// Calculates a normal soft, taking into account the six adjacent triangles:
//
//	^ y
//	|
//	b---c---+
//	|\  |\  |
//	|  \|  \|
//	a---o---d
//	|\  |\  |
//	|  \|  \|
//	+---f---e--> x

D3DVERTEX2 CTerrain::RetVertex(int x, int y, int step)
{
	D3DVERTEX2	v;
	Math::Vector	o, oo, a,b,c,d,e,f, n, s;
	int			brick;

	o = RetVector(x, y);
	v.x = o.x;
	v.y = o.y;
	v.z = o.z;

	a = RetVector(x-step, y     );
	b = RetVector(x-step, y+step);
	c = RetVector(x,      y+step);
	d = RetVector(x+step, y     );
	e = RetVector(x+step, y-step);
	f = RetVector(x,      y-step);

	s = Math::Vector(0.0f, 0.0f, 0.0f);

	if ( x-step >= 0 && y+step <= m_mosaic*m_brick+1 )
	{
		s += Math::NormalToPlane(b,a,o);
		s += Math::NormalToPlane(c,b,o);
	}

	if ( x+step <= m_mosaic*m_brick+1 && y+step <= m_mosaic*m_brick+1 )
	{
		s += Math::NormalToPlane(d,c,o);
	}

	if ( x+step <= m_mosaic*m_brick+1 && y-step >= 0 )
	{
		s += Math::NormalToPlane(e,d,o);
		s += Math::NormalToPlane(f,e,o);
	}

	if ( x-step >= 0 && y-step >= 0 )
	{
		s += Math::NormalToPlane(a,f,o);
	}

	s = Normalize(s);
	v.nx = s.x;
	v.ny = s.y;
	v.nz = s.z;

	if ( m_bMultiText )
	{
		brick = m_brick/m_subdivMapping;
		oo = RetVector((x/brick)*brick, (y/brick)*brick);
		o  = RetVector(x, y);
		v.tu =        (o.x-oo.x)*m_scaleMapping*m_subdivMapping;
		v.tv = 1.0f - (o.z-oo.z)*m_scaleMapping*m_subdivMapping;
	}
	else
	{
		v.tu = o.x*m_scaleMapping;
		v.tv = o.z*m_scaleMapping;
	}

	return v;
}

// Creates all objects of a mosaic.
// The origin of mosaic is his center.
//
//	^ z
//	|
//	|  2---4---6--
//	|  |\  |\  |\
//	|  |  \|  \|
//	|  1---3---5--- ...
//	|
//	+-------------------> x

bool CTerrain::CreateMosaic(int ox, int oy, int step, int objRank, 
							const D3DMATERIAL7 &mat,
							float min, float max)
{
	Math::Matrix		transform;
	D3DVERTEX2		o, p1, p2;
	D3DObjLevel6*	buffer;
	Math::Point			uv;
	int				brick, total, size, mx, my, x, y, xx, yy, i;
	char			texName1[20];
	char			texName2[20];
	float			pixel, dp;

	if ( step == 1 && m_engine->RetGroundSpot() )
	{
		i = (ox/5) + (oy/5)*(m_mosaic/5);
		sprintf(texName2, "shadow%.2d.tga", i);
	}
	else
	{
		texName2[0] = 0;
	}

	brick = m_brick/m_subdivMapping;

	o = RetVertex(ox*m_brick+m_brick/2, oy*m_brick+m_brick/2, step);
	total = ((brick/step)+1)*2;
	size = sizeof(D3DObjLevel6)+sizeof(D3DVERTEX2)*(total-1);

	pixel = 1.0f/256.0f;  // 1 pixel cover (*)
//?	dp = 0.5f/512.0f;
	dp = 1.0f/512.0f;

	for ( my=0 ; my<m_subdivMapping ; my++ )
	{
		for ( mx=0 ; mx<m_subdivMapping ; mx++ )
		{
			if ( m_bLevelText )
			{
				xx = ox*m_brick + mx*(m_brick/m_subdivMapping);
				yy = oy*m_brick + my*(m_brick/m_subdivMapping);
				LevelTextureName(xx, yy, texName1, uv);
			}
			else
			{
				i = (ox*m_subdivMapping+mx)+(oy*m_subdivMapping+my)*m_mosaic;
				sprintf(texName1, "%s%.3d%s", m_texBaseName, m_texture[i], m_texBaseExt);
			}

			for ( y=0 ; y<brick ; y+=step )
			{
				buffer = (D3DObjLevel6*)malloc(size);
				ZeroMemory(buffer, sizeof(D3DObjLevel6));
				buffer->totalPossible = total;
				buffer->totalUsed = total;
				buffer->type     = D3DTYPE6S;
				buffer->material = mat;
				if ( m_bMultiText )
				{
//?					buffer->state = D3DSTATENORMAL;
					buffer->state = D3DSTATEWRAP;
				}
				else
				{
					buffer->state = D3DSTATEWRAP;
				}
				buffer->state |= D3DSTATESECOND;
				if ( step == 1 )
				{
					buffer->state |= D3DSTATEDUALb;
				}
				i = 0;
				for ( x=0 ; x<=brick ; x+=step )
				{
					p1 = RetVertex(ox*m_brick+mx*brick+x, oy*m_brick+my*brick+y+0   , step);
					p2 = RetVertex(ox*m_brick+mx*brick+x, oy*m_brick+my*brick+y+step, step);
					p1.x -= o.x;  p1.z -= o.z;
					p2.x -= o.x;  p2.z -= o.z;

					if ( m_bMultiText )
					{
						if ( x == 0 )
						{
							p1.tu = 0.0f+(0.5f/256.0f);
							p2.tu = 0.0f+(0.5f/256.0f);
						}
						if ( x == brick )
						{
							p1.tu = 1.0f-(0.5f/256.0f);
							p2.tu = 1.0f-(0.5f/256.0f);
						}
						if ( y == 0 )
						{
							p1.tv = 1.0f-(0.5f/256.0f);
						}
						if ( y == brick-step )
						{
							p2.tv = 0.0f+(0.5f/256.0f);
						}
					}

					if ( m_bLevelText )
					{
						p1.tu /= m_subdivMapping;  // 0..1 -> 0..0.25
						p1.tv /= m_subdivMapping;
						p2.tu /= m_subdivMapping;
						p2.tv /= m_subdivMapping;

						if ( x == 0 )
						{
							p1.tu = 0.0f+dp;
							p2.tu = 0.0f+dp;
						}
						if ( x == brick )
						{
							p1.tu = (1.0f/m_subdivMapping)-dp;
							p2.tu = (1.0f/m_subdivMapping)-dp;
						}
						if ( y == 0 )
						{
							p1.tv = (1.0f/m_subdivMapping)-dp;
						}
						if ( y == brick-step )
						{
							p2.tv = 0.0f+dp;
						}

						p1.tu += uv.x;
						p1.tv += uv.y;
						p2.tu += uv.x;
						p2.tv += uv.y;
					}

#if 1
					xx = mx*(m_brick/m_subdivMapping) + x;
					yy = my*(m_brick/m_subdivMapping) + y;
					p1.tu2 = ((float)(ox%5)*m_brick+xx+0.0f)/(m_brick*5);
					p1.tv2 = ((float)(oy%5)*m_brick+yy+0.0f)/(m_brick*5);
					p2.tu2 = ((float)(ox%5)*m_brick+xx+0.0f)/(m_brick*5);
					p2.tv2 = ((float)(oy%5)*m_brick+yy+1.0f)/(m_brick*5);

					// Correction for 1 pixel cover (*).
					p1.tu2 = (p1.tu2+pixel)*(1.0f-pixel)/(1.0f+pixel);
					p1.tv2 = (p1.tv2+pixel)*(1.0f-pixel)/(1.0f+pixel);
					p2.tu2 = (p2.tu2+pixel)*(1.0f-pixel)/(1.0f+pixel);
					p2.tv2 = (p2.tv2+pixel)*(1.0f-pixel)/(1.0f+pixel);
#endif

					buffer->vertex[i++] = p1;
					buffer->vertex[i++] = p2;
				}
				m_engine->AddQuick(objRank, buffer, texName1, texName2, min, max, true);
			}
		}
	}

	transform.LoadIdentity();
	transform.Set(1, 4, o.x);
	transform.Set(3, 4, o.z);
	m_engine->SetObjectTransform(objRank, transform);

	return true;
}

// (*) There is 1 pixel cover around each of the 16 surfaces:
//
//	|<--------------256-------------->|
//	|   |<----------254---------->|   |
//	|---|---|---|-- ... --|---|---|---|
//    |  0.0                   1.0  |
//	  |   |                     |   |
//   0.0 min                   max 1.0
//
// The uv coordinates used for texturing are between min and max (instead of 0 and 1).
// This allows to exclude the pixels situated in a margin of a pixel around the surface.


// Seeks a materials based on theirs identifier.

TerrainMaterial* CTerrain::LevelSearchMat(int id)
{
	int		i;

	for ( i=0 ; i<m_levelMatTotal ; i++ )
	{
		if ( id == m_levelMat[i].id )
		{
			return &m_levelMat[i];
		}
	}

	return 0;
}

// Chooses texture to use for a given square.

void CTerrain::LevelTextureName(int x, int y, char *name, Math::Point &uv)
{
	TerrainMaterial*	tm;

	x /= m_brick/m_subdivMapping;
	y /= m_brick/m_subdivMapping;

	tm = LevelSearchMat(m_levelDot[x+y*m_levelDotSize].id);
	if ( tm == 0 )
	{
		strcpy(name, "xxx.tga");
		uv.x = 0.0f;
		uv.y = 0.0f;
	}
	else
	{
//?		sprintf(name, "%s.tga", tm->texName);
		strcpy(name, tm->texName);
		uv.x = tm->u;
		uv.y = tm->v;
	}
}

// Returns the height of the terrain.

float CTerrain::LevelRetHeight(int x, int y)
{
	int		size;

	size = (m_mosaic*m_brick+1);

	if ( x <  0    )  x = 0;
	if ( x >= size )  x = size-1;
	if ( y <  0    )  y = 0;
	if ( y >= size )  y = size-1;

	return m_relief[x+y*size];
}

// Decide whether a point is using the materials.

bool CTerrain::LevelGetDot(int x, int y, float min, float max, float slope)
{
	float	hc, h[4];
	int		i;

	hc   = LevelRetHeight(x, y);
	h[0] = LevelRetHeight(x+0, y+1);
	h[1] = LevelRetHeight(x+1, y+0);
	h[2] = LevelRetHeight(x+0, y-1);
	h[3] = LevelRetHeight(x-1, y+0);

	if ( hc < min ||
		 hc > max )  return false;

	if ( slope == 0.0f )
	{
		return true;
	}

	if ( slope > 0.0f )
	{
		for ( i=0 ; i<4 ; i++ )
		{
			if ( fabs(hc-h[i]) >= slope )
			{
				return false;
			}
		}
		return true;
	}

	if ( slope < 0.0f )
	{
		for ( i=0 ; i<4 ; i++ )
		{
			if ( fabs(hc-h[i]) < -slope )
			{
				return false;
			}
		}
		return true;
	}

	return false;
}

// Seeks if material exists.
// Returns the index within m_levelMat or -1 if there is not.
// m_levelMat[i].id gives the identifier.

int CTerrain::LevelTestMat(char *mat)
{
	int		i;

	for ( i=0 ; i<m_levelMatTotal ; i++ )
	{
		if ( m_levelMat[i].mat[0] == mat[0] &&
			 m_levelMat[i].mat[1] == mat[1] &&
			 m_levelMat[i].mat[2] == mat[2] &&
			 m_levelMat[i].mat[3] == mat[3] )  return i;
	}

	return -1;
}

// Modifies the state of a point and its four neighbors, without testing if possible.

void CTerrain::LevelSetDot(int x, int y, int id, char *mat)
{
	TerrainMaterial*	tm;
	int					i, ii;

	tm = LevelSearchMat(id);
	if ( tm == 0 )  return;

	if ( tm->mat[0] != mat[0] ||
		 tm->mat[1] != mat[1] ||
		 tm->mat[2] != mat[2] ||
		 tm->mat[3] != mat[3] )  // id incompatible with mat?
	{
		ii = LevelTestMat(mat);
		if ( ii == -1 )  return;
		id = m_levelMat[ii].id;  // looking for a id compatible with mat
	}

	// Changes the point.
	m_levelDot[x+y*m_levelDotSize].id     = id;
	m_levelDot[x+y*m_levelDotSize].mat[0] = mat[0];
	m_levelDot[x+y*m_levelDotSize].mat[1] = mat[1];
	m_levelDot[x+y*m_levelDotSize].mat[2] = mat[2];
	m_levelDot[x+y*m_levelDotSize].mat[3] = mat[3];

	// Changes the lower neighbor.
	if ( (x+0) >= 0 && (x+0) < m_levelDotSize &&
		 (y-1) >= 0 && (y-1) < m_levelDotSize )
	{
		i = (x+0)+(y-1)*m_levelDotSize;
		if ( m_levelDot[i].mat[0] != mat[2] )
		{
			m_levelDot[i].mat[0] = mat[2];
			ii = LevelTestMat(m_levelDot[i].mat);
			if ( ii != -1 )
			{
				m_levelDot[i].id = m_levelMat[ii].id;
			}
		}
	}

	// Modifies the left neighbor.
	if ( (x-1) >= 0 && (x-1) < m_levelDotSize &&
		 (y+0) >= 0 && (y+0) < m_levelDotSize )
	{
		i = (x-1)+(y+0)*m_levelDotSize;
		if ( m_levelDot[i].mat[1] != mat[3] )
		{
			m_levelDot[i].mat[1] = mat[3];
			ii = LevelTestMat(m_levelDot[i].mat);
			if ( ii != -1 )
			{
				m_levelDot[i].id = m_levelMat[ii].id;
			}
		}
	}

	// Changes the upper neighbor.
	if ( (x+0) >= 0 && (x+0) < m_levelDotSize &&
		 (y+1) >= 0 && (y+1) < m_levelDotSize )
	{
		i = (x+0)+(y+1)*m_levelDotSize;
		if ( m_levelDot[i].mat[2] != mat[0] )
		{
			m_levelDot[i].mat[2] = mat[0];
			ii = LevelTestMat(m_levelDot[i].mat);
			if ( ii != -1 )
			{
				m_levelDot[i].id = m_levelMat[ii].id;
			}
		}
	}

	// Changes the right neighbor.
	if ( (x+1) >= 0 && (x+1) < m_levelDotSize &&
		 (y+0) >= 0 && (y+0) < m_levelDotSize )
	{
		i = (x+1)+(y+0)*m_levelDotSize;
		if ( m_levelDot[i].mat[3] != mat[1] )
		{
			m_levelDot[i].mat[3] = mat[1];
			ii = LevelTestMat(m_levelDot[i].mat);
			if ( ii != -1 )
			{
				m_levelDot[i].id = m_levelMat[ii].id;
			}
		}
	}
}

// Tests if a material can give a place, according to its four neighbors.
// If yes, puts the point.

bool CTerrain::LevelIfDot(int x, int y, int id, char *mat)
{
	char			test[4];

	// Compatible with lower neighbor?
	if ( x+0 >= 0 && x+0 < m_levelDotSize &&
		 y-1 >= 0 && y-1 < m_levelDotSize )
	{
		test[0] = mat[2];
		test[1] = m_levelDot[(x+0)+(y-1)*m_levelDotSize].mat[1];
		test[2] = m_levelDot[(x+0)+(y-1)*m_levelDotSize].mat[2];
		test[3] = m_levelDot[(x+0)+(y-1)*m_levelDotSize].mat[3];

		if ( LevelTestMat(test) == -1 )  return false;
	}

	// Compatible with left neighbor?
	if ( x-1 >= 0 && x-1 < m_levelDotSize &&
		 y+0 >= 0 && y+0 < m_levelDotSize )
	{
		test[0] = m_levelDot[(x-1)+(y+0)*m_levelDotSize].mat[0];
		test[1] = mat[3];
		test[2] = m_levelDot[(x-1)+(y+0)*m_levelDotSize].mat[2];
		test[3] = m_levelDot[(x-1)+(y+0)*m_levelDotSize].mat[3];

		if ( LevelTestMat(test) == -1 )  return false;
	}

	// Compatible with upper neighbor?
	if ( x+0 >= 0 && x+0 < m_levelDotSize &&
		 y+1 >= 0 && y+1 < m_levelDotSize )
	{
		test[0] = m_levelDot[(x+0)+(y+1)*m_levelDotSize].mat[0];
		test[1] = m_levelDot[(x+0)+(y+1)*m_levelDotSize].mat[1];
		test[2] = mat[0];
		test[3] = m_levelDot[(x+0)+(y+1)*m_levelDotSize].mat[3];

		if ( LevelTestMat(test) == -1 )  return false;
	}

	// Compatible with right neighbor?
	if ( x+1 >= 0 && x+1 < m_levelDotSize &&
		 y+0 >= 0 && y+0 < m_levelDotSize )
	{
		test[0] = m_levelDot[(x+1)+(y+0)*m_levelDotSize].mat[0];
		test[1] = m_levelDot[(x+1)+(y+0)*m_levelDotSize].mat[1];
		test[2] = m_levelDot[(x+1)+(y+0)*m_levelDotSize].mat[2];
		test[3] = mat[1];

		if ( LevelTestMat(test) == -1 )  return false;
	}

	LevelSetDot(x, y, id, mat);  // puts the point
	return true;
}

// Modifies the state of a point.

bool CTerrain::LevelPutDot(int x, int y, int id)
{
	TerrainMaterial	*tm;
	char			mat[4];
	int				up, right, down, left;

	x /= m_brick/m_subdivMapping;
	y /= m_brick/m_subdivMapping;

	if ( x < 0 || x >= m_levelDotSize ||
		 y < 0 || y >= m_levelDotSize )  return false;

	tm = LevelSearchMat(id);
	if ( tm == 0 )  return false;

	// Tries without changing neighbors.
	if ( LevelIfDot(x, y, id, tm->mat) )  return true;

	// Tries changing a single neighbor (4x).
	for ( up=0 ; up<m_levelMatMax ; up++ )
	{
		mat[0] = up;
		mat[1] = tm->mat[1];
		mat[2] = tm->mat[2];
		mat[3] = tm->mat[3];

		if ( LevelIfDot(x, y, id, mat) )  return true;
	}

	for ( right=0 ; right<m_levelMatMax ; right++ )
	{
		mat[0] = tm->mat[0];
		mat[1] = right;
		mat[2] = tm->mat[2];
		mat[3] = tm->mat[3];

		if ( LevelIfDot(x, y, id, mat) )  return true;
	}

	for ( down=0 ; down<m_levelMatMax ; down++ )
	{
		mat[0] = tm->mat[0];
		mat[1] = tm->mat[1];
		mat[2] = down;
		mat[3] = tm->mat[3];

		if ( LevelIfDot(x, y, id, mat) )  return true;
	}

	for ( left=0 ; left<m_levelMatMax ; left++ )
	{
		mat[0] = tm->mat[0];
		mat[1] = tm->mat[1];
		mat[2] = tm->mat[2];
		mat[3] = left;

		if ( LevelIfDot(x, y, id, mat) )  return true;
	}

	// Tries changing two neighbors (6x).
	for ( up=0 ; up<m_levelMatMax ; up++ )
	{
		for ( down=0 ; down<m_levelMatMax ; down++ )
		{
			mat[0] = up;
			mat[1] = tm->mat[1];
			mat[2] = down;
			mat[3] = tm->mat[3];

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	for ( right=0 ; right<m_levelMatMax ; right++ )
	{
		for ( left=0 ; left<m_levelMatMax ; left++ )
		{
			mat[0] = tm->mat[0];
			mat[1] = right;
			mat[2] = tm->mat[2];
			mat[3] = left;

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	for ( up=0 ; up<m_levelMatMax ; up++ )
	{
		for ( right=0 ; right<m_levelMatMax ; right++ )
		{
			mat[0] = up;
			mat[1] = right;
			mat[2] = tm->mat[2];
			mat[3] = tm->mat[3];

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	for ( right=0 ; right<m_levelMatMax ; right++ )
	{
		for ( down=0 ; down<m_levelMatMax ; down++ )
		{
			mat[0] = tm->mat[0];
			mat[1] = right;
			mat[2] = down;
			mat[3] = tm->mat[3];

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	for ( down=0 ; down<m_levelMatMax ; down++ )
	{
		for ( left=0 ; left<m_levelMatMax ; left++ )
		{
			mat[0] = tm->mat[0];
			mat[1] = tm->mat[1];
			mat[2] = down;
			mat[3] = left;

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	for ( up=0 ; up<m_levelMatMax ; up++ )
	{
		for ( left=0 ; left<m_levelMatMax ; left++ )
		{
			mat[0] = up;
			mat[1] = tm->mat[1];
			mat[2] = tm->mat[2];
			mat[3] = left;

			if ( LevelIfDot(x, y, id, mat) )  return true;
		}
	}

	// Tries changing all the neighbors.
	for ( up=0 ; up<m_levelMatMax ; up++ )
	{
		for ( right=0 ; right<m_levelMatMax ; right++ )
		{
			for ( down=0 ; down<m_levelMatMax ; down++ )
			{
				for ( left=0 ; left<m_levelMatMax ; left++ )
				{
					mat[0] = up;
					mat[1] = right;
					mat[2] = down;
					mat[3] = left;

					if ( LevelIfDot(x, y, id, mat) )  return true;
				}
			}
		}
	}

	OutputDebugString("LevelPutDot error\n");
	return false;
}

// Initializes all the ground with a material.

bool CTerrain::LevelInit(int id)
{
	TerrainMaterial*	tm;
	int					i, j;

	tm = LevelSearchMat(id);
	if ( tm == 0 )  return false;

	for ( i=0 ; i<m_levelDotSize*m_levelDotSize ; i++ )
	{
		m_levelDot[i].id = id;

		for ( j=0 ; j<4 ; j++ )
		{
			m_levelDot[i].mat[j] = tm->mat[j];
		}
	}

	return true;
}

// Generates a level in the terrain.

bool CTerrain::LevelGenerate(int *id, float min, float max,
							 float slope, float freq,
							 Math::Vector center, float radius)
{
	TerrainMaterial	*tm;
	Math::Vector		pos;
	int				i, numID, x, y, xx, yy, group, rnd;
	float			dim;

	static char random[100] =
	{
		84,25,12, 6,34,52,85,38,97,16,
		21,31,65,19,62,40,72,22,48,61,
		56,47, 8,53,73,77, 4,91,26,88,
		76, 1,44,93,39,11,71,17,98,95,
		88,83,18,30, 3,57,28,49,74, 9,
		32,13,96,66,15,70,36,10,59,94,
		45,86, 2,29,63,42,51, 0,79,27,
		54, 7,20,69,89,23,64,43,81,92,
		90,33,46,14,67,35,50, 5,87,60,
		68,55,24,78,41,75,58,80,37,82,
	};

	i = 0;
	while ( id[i] != 0 )
	{
		tm = LevelSearchMat(id[i++]);
		if ( tm == 0 )  return false;
	}
	numID = i;

	group = m_brick/m_subdivMapping;

	if ( radius > 0.0f && radius < 5.0f )  // just a square?
	{
		dim = (m_mosaic*m_brick*m_size)/2.0f;

		xx = (int)((center.x+dim)/m_size);
		yy = (int)((center.z+dim)/m_size);

		x = xx/group;
		y = yy/group;

		tm = LevelSearchMat(id[0]);
		if ( tm != 0 )
		{
			LevelSetDot(x, y, id[0], tm->mat);  // puts the point
		}
//?		LevelPutDot(xx,yy, id[0]);
	}
	else
	{
		for ( y=0 ; y<m_levelDotSize ; y++ )
		{
			for ( x=0 ; x<m_levelDotSize ; x++ )
			{
				if ( radius != 0.0f )
				{
					pos.x = ((float)x-m_levelDotSize/2.0f)*group*m_size;
					pos.z = ((float)y-m_levelDotSize/2.0f)*group*m_size;
					if ( Math::DistanceProjected(pos, center) > radius )  continue;
				}

				if ( freq < 100.0f )
				{
					rnd = random[(x%10)+(y%10)*10];
					if ( (float)rnd > freq )  continue;
				}

				xx = x*group + group/2;
				yy = y*group + group/2;

				if ( LevelGetDot(xx,yy, min, max, slope) )
				{
					rnd = random[(x%10)+(y%10)*10];
					i = rnd%numID;
					LevelPutDot(xx,yy, id[i]);
				}
			}
		}
	}

	return true;
}

// Initializes an table with empty levels.

void CTerrain::LevelOpenTable()
{
	int		i, j;

	if ( !m_bLevelText )  return;
	if ( m_levelDot != 0 )  return;  // already allocated

	m_levelDotSize = (m_mosaic*m_brick)/(m_brick/m_subdivMapping)+1;
	m_levelDot = (DotLevel*)malloc(m_levelDotSize*m_levelDotSize*sizeof(DotLevel));

	for ( i=0 ; i<m_levelDotSize*m_levelDotSize ; i++ )
	{
		for ( j=0 ; j<4 ; j++ )
		{
			m_levelDot[i].mat[j] = 0;
		}
	}
}

// Closes the level table.

void CTerrain::LevelCloseTable()
{
	free(m_levelDot);
	m_levelDot = 0;
}



// Creates all objects in a mesh square ground.

bool CTerrain::CreateSquare(bool bMultiRes, int x, int y)
{
	D3DMATERIAL7	mat;
	float			min, max;
	int				step, objRank;

	ZeroMemory( &mat, sizeof(D3DMATERIAL7) );
	mat.diffuse.r = 1.0f;
	mat.diffuse.g = 1.0f;
	mat.diffuse.b = 1.0f;
	mat.ambient.r = 0.0f;
	mat.ambient.g = 0.0f;
	mat.ambient.b = 0.0f;

	objRank = m_engine->CreateObject();
	m_engine->SetObjectType(objRank, TYPETERRAIN);  // it is a terrain

	m_objRank[x+y*m_mosaic] = objRank;

	if ( bMultiRes )
	{
		min = 0.0f;
		max = m_vision;
		max *= m_engine->RetClippingDistance();
		for ( step=0 ; step<m_depth ; step++ )
		{
			CreateMosaic(x, y, 1<<step, objRank, mat, min, max);
			min = max;
			max *= 2;
			if ( step == m_depth-1 )  max = g_HUGE;
		}
	}
	else
	{
		CreateMosaic(x, y, 1, objRank, mat, 0.0f, g_HUGE);
	}

	return true;
}

// Creates all objects of the terrain within the 3D engine.

bool CTerrain::CreateObjects(bool bMultiRes)
{
	int		x, y;

	AdjustRelief();

	for ( y=0 ; y<m_mosaic ; y++ )
	{
		for ( x=0 ; x<m_mosaic ; x++ )
		{
			CreateSquare(bMultiRes, x, y);
		}
	}

	return true;
}


// Modifies the terrain's relief.
// ATTENTION: ok only with m_depth = 2!

bool CTerrain::Terraform(const Math::Vector &p1, const Math::Vector &p2, float height)
{
	POINT		tp1, tp2, pp1, pp2;
	float		dim, avg;
	int			x, y, size, nb;

	dim = (m_mosaic*m_brick*m_size)/2.0f;
	tp1.x = (int)((p1.x+dim+m_size/2.0f)/m_size);
	tp1.y = (int)((p1.z+dim+m_size/2.0f)/m_size);
	tp2.x = (int)((p2.x+dim+m_size/2.0f)/m_size);
	tp2.y = (int)((p2.z+dim+m_size/2.0f)/m_size);

	if ( tp1.x > tp2.x )
	{
		x     = tp1.x;
		tp1.x = tp2.x;
		tp2.x = x;
	}

	if ( tp1.y > tp2.y )
	{
		y     = tp1.y;
		tp1.y = tp2.y;
		tp2.y = y;
	}

	size = (m_mosaic*m_brick)+1;

	// Calculates the current average height.
	avg = 0.0f;
	nb = 0;
	for ( y=tp1.y ; y<=tp2.y ; y++ )
	{
		for ( x=tp1.x ; x<=tp2.x ; x++ )
		{
			avg += m_relief[x+y*size];
			nb ++;
		}
	}
	avg /= (float)nb;

	// Changes the description of the relief.
	for ( y=tp1.y ; y<=tp2.y ; y++ )
	{
		for ( x=tp1.x ; x<=tp2.x ; x++ )
		{
			m_relief[x+y*size] = avg+height;

			if ( x%m_brick == 0 && y%m_depth != 0 )
			{
				m_relief[(x+0)+(y-1)*size] = avg+height;
				m_relief[(x+0)+(y+1)*size] = avg+height;
			}

			if ( y%m_brick == 0 && x%m_depth != 0 )
			{
				m_relief[(x-1)+(y+0)*size] = avg+height;
				m_relief[(x+1)+(y+0)*size] = avg+height;
			}
		}
	}
	AdjustRelief();

	pp1.x = (tp1.x-2)/m_brick;
	pp1.y = (tp1.y-2)/m_brick;
	pp2.x = (tp2.x+1)/m_brick;
	pp2.y = (tp2.y+1)/m_brick;

	if ( pp1.x <  0        )  pp1.x = 0;
	if ( pp1.x >= m_mosaic )  pp1.x = m_mosaic-1;
	if ( pp1.y <  0        )  pp1.y = 0;
	if ( pp1.y >= m_mosaic )  pp1.y = m_mosaic-1;

	for ( y=pp1.y ; y<=pp2.y ; y++ )
	{
		for ( x=pp1.x ; x<=pp2.x ; x++ )
		{
			m_engine->DeleteObject(m_objRank[x+y*m_mosaic]);
			CreateSquare(m_bMultiText, x, y);  // recreates the square
		}
	}
	m_engine->Update();

	return true;
}


// Management of the wind.

void CTerrain::SetWind(Math::Vector speed)
{
	m_wind = speed;
}

Math::Vector CTerrain::RetWind()
{
	return m_wind;
}


// Gives the exact slope of the terrain of a place given.

float CTerrain::RetFineSlope(const Math::Vector &pos)
{
	Math::Vector	n;

	if ( !GetNormal(n, pos) )  return 0.0f;
	return fabs(Math::RotateAngle(Math::Point(n.x, n.z).Length(), n.y)-Math::PI/2.0f);
}

// Gives the approximate slope of the terrain of a specific location.

float CTerrain::RetCoarseSlope(const Math::Vector &pos)
{
	float	dim, level[4], min, max;
	int		x, y;

	if ( m_relief == 0 )  return 0.0f;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((pos.x+dim)/m_size);
	y = (int)((pos.z+dim)/m_size);

	if ( x < 0 || x >= m_mosaic*m_brick ||
		 y < 0 || y >= m_mosaic*m_brick )  return 0.0f;

	level[0] = m_relief[(x+0)+(y+0)*(m_mosaic*m_brick+1)];
	level[1] = m_relief[(x+1)+(y+0)*(m_mosaic*m_brick+1)];
	level[2] = m_relief[(x+0)+(y+1)*(m_mosaic*m_brick+1)];
	level[3] = m_relief[(x+1)+(y+1)*(m_mosaic*m_brick+1)];

	min = Math::Min(level[0], level[1], level[2], level[3]);
	max = Math::Max(level[0], level[1], level[2], level[3]);

	return atanf((max-min)/m_size);
}

// Gives the normal vector at the position p (x,-,z) of the ground.

bool CTerrain::GetNormal(Math::Vector &n, const Math::Vector &p)
{
	Math::Vector	p1, p2, p3, p4;
	float		dim;
	int			x, y;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((p.x+dim)/m_size);
	y = (int)((p.z+dim)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return false;

	p1 = RetVector(x+0, y+0);
	p2 = RetVector(x+1, y+0);
	p3 = RetVector(x+0, y+1);
	p4 = RetVector(x+1, y+1);

	if ( fabs(p.z-p2.z) < fabs(p.x-p2.x) )
	{
		n = Math::NormalToPlane(p1,p2,p3);
	}
	else
	{
		n = Math::NormalToPlane(p2,p4,p3);
	}
	return true;
}

// Returns the height of the ground.

float CTerrain::RetFloorLevel(const Math::Vector &p, bool bBrut, bool bWater)
{
	Math::Vector	p1, p2, p3, p4, ps;
	float		dim, level;
	int			x, y;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((p.x+dim)/m_size);
	y = (int)((p.z+dim)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return false;

	p1 = RetVector(x+0, y+0);
	p2 = RetVector(x+1, y+0);
	p3 = RetVector(x+0, y+1);
	p4 = RetVector(x+1, y+1);

	ps = p;
	if ( fabs(p.z-p2.z) < fabs(p.x-p2.x) )
	{
		if ( !IntersectY(p1, p2, p3, ps) )  return 0.0f;
	}
	else
	{
		if ( !IntersectY(p2, p4, p3, ps) )  return 0.0f;
	}

	if ( !bBrut )  AdjustBuildingLevel(ps);

	if ( bWater )  // not going underwater?
	{
		level = m_water->RetLevel();
		if ( ps.y < level )  ps.y = level;  // not under water
	}

	return ps.y;
}

// Returns the height to the ground. 
// This height is positive when you are above the ground.

float CTerrain::RetFloorHeight(const Math::Vector &p, bool bBrut, bool bWater)
{
	Math::Vector	p1, p2, p3, p4, ps;
	float		dim, level;
	int			x, y;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((p.x+dim)/m_size);
	y = (int)((p.z+dim)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return false;

	p1 = RetVector(x+0, y+0);
	p2 = RetVector(x+1, y+0);
	p3 = RetVector(x+0, y+1);
	p4 = RetVector(x+1, y+1);

	ps = p;
	if ( fabs(p.z-p2.z) < fabs(p.x-p2.x) )
	{
		if ( !IntersectY(p1, p2, p3, ps) )  return 0.0f;
	}
	else
	{
		if ( !IntersectY(p2, p4, p3, ps) )  return 0.0f;
	}

	if ( !bBrut )  AdjustBuildingLevel(ps);

	if ( bWater )  // not going underwater?
	{
		level = m_water->RetLevel();
		if ( ps.y < level )  ps.y = level;  // not under water
	}

	return p.y-ps.y;
}

// Modifies the coordinate "y" of point "p" to rest on the ground floor.

bool CTerrain::MoveOnFloor(Math::Vector &p, bool bBrut, bool bWater)
{
	Math::Vector	p1, p2, p3, p4;
	float		dim, level;
	int			x, y;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((p.x+dim)/m_size);
	y = (int)((p.z+dim)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return false;

	p1 = RetVector(x+0, y+0);
	p2 = RetVector(x+1, y+0);
	p3 = RetVector(x+0, y+1);
	p4 = RetVector(x+1, y+1);

	if ( fabs(p.z-p2.z) < fabs(p.x-p2.x) )
	{
		if ( !IntersectY(p1, p2, p3, p) )  return false;
	}
	else
	{
		if ( !IntersectY(p2, p4, p3, p) )  return false;
	}

	if ( !bBrut )  AdjustBuildingLevel(p);

	if ( bWater )  // not going underwater?
	{
		level = m_water->RetLevel();
		if ( p.y < level )  p.y = level;  // not under water
	}

	return true;
}

// Modifies a coordinate so that it is on the ground.
// Returns false if the initial coordinate was too far.

bool CTerrain::ValidPosition(Math::Vector &p, float marging)
{
	bool	bOK = true;
	float	limit;

	limit = m_mosaic*m_brick*m_size/2.0f - marging;

	if ( p.x < -limit )
	{
		p.x = -limit;
		bOK = false;
	}

	if ( p.z < -limit )
	{
		p.z = -limit;
		bOK = false;
	}

	if ( p.x > limit )
	{
		p.x = limit;
		bOK = false;
	}

	if ( p.z > limit )
	{
		p.z = limit;
		bOK = false;
	}

	return bOK;
}



// Empty the table of elevations.

void CTerrain::FlushBuildingLevel()
{
	m_buildingUsed = 0;
}

// Adds a new elevation for a building.

bool CTerrain::AddBuildingLevel(Math::Vector center, float min, float max,
								float height, float factor)
{
	int		i;

	for ( i=0 ; i<m_buildingUsed ; i++ )
	{
		if ( center.x == m_buildingTable[i].center.x &&
			 center.z == m_buildingTable[i].center.z )
		{
			goto update;
		}
	}

	if ( m_buildingUsed >= MAXBUILDINGLEVEL )  return false;
	i = m_buildingUsed++;

	update:
	m_buildingTable[i].center   = center;
	m_buildingTable[i].min      = min;
	m_buildingTable[i].max      = max;
	m_buildingTable[i].level    = RetFloorLevel(center, true);
	m_buildingTable[i].height   = height;
	m_buildingTable[i].factor   = factor;
	m_buildingTable[i].bboxMinX = center.x-max;
	m_buildingTable[i].bboxMaxX = center.x+max;
	m_buildingTable[i].bboxMinZ = center.z-max;
	m_buildingTable[i].bboxMaxZ = center.z+max;

	return true;
}

// Updates the elevation for a building when it was moved up (after a terraforming).

bool CTerrain::UpdateBuildingLevel(Math::Vector center)
{
	int		i;

	for ( i=0 ; i<m_buildingUsed ; i++ )
	{
		if ( center.x == m_buildingTable[i].center.x &&
			 center.z == m_buildingTable[i].center.z )
		{
			m_buildingTable[i].center = center;
			m_buildingTable[i].level  = RetFloorLevel(center, true);
			return true;
		}
	}
	return false;
}

// Removes the elevation for a building when it was destroyed.

bool CTerrain::DeleteBuildingLevel(Math::Vector center)
{
	int		i, j;

	for ( i=0 ; i<m_buildingUsed ; i++ )
	{
		if ( center.x == m_buildingTable[i].center.x &&
			 center.z == m_buildingTable[i].center.z )
		{
			for ( j=i+1 ; j<m_buildingUsed ; j++ )
			{
				m_buildingTable[j-1] = m_buildingTable[j];
			}
			m_buildingUsed --;
			return true;
		}
	}
	return false;
}

// Returns the influence factor whether a position is on a possible rise.

float CTerrain::RetBuildingFactor(const Math::Vector &p)
{
	float		dist;
	int			i;

	for ( i=0 ; i<m_buildingUsed ; i++ )
	{
		if ( p.x < m_buildingTable[i].bboxMinX ||
			 p.x > m_buildingTable[i].bboxMaxX ||
			 p.z < m_buildingTable[i].bboxMinZ ||
			 p.z > m_buildingTable[i].bboxMaxZ )  continue;

		dist = Math::DistanceProjected(p, m_buildingTable[i].center);

		if ( dist <= m_buildingTable[i].max )
		{
			return m_buildingTable[i].factor;
		}
	}
	return 1.0f;  // it is normal on the ground
}

// Adjusts a position according to a possible rise.

void CTerrain::AdjustBuildingLevel(Math::Vector &p)
{
	Math::Vector	border;
	float		dist, base;
	int			i;

	for ( i=0 ; i<m_buildingUsed ; i++ )
	{
		if ( p.x < m_buildingTable[i].bboxMinX ||
			 p.x > m_buildingTable[i].bboxMaxX ||
			 p.z < m_buildingTable[i].bboxMinZ ||
			 p.z > m_buildingTable[i].bboxMaxZ )  continue;

		dist = Math::DistanceProjected(p, m_buildingTable[i].center);

		if ( dist > m_buildingTable[i].max )  continue;

		if ( dist < m_buildingTable[i].min )
		{
			p.y = m_buildingTable[i].level+m_buildingTable[i].height;
			return;
		}

#if 0
		p.y = m_buildingTable[i].level;
		p.y += (m_buildingTable[i].max-dist)/
			   (m_buildingTable[i].max-m_buildingTable[i].min)*
			   m_buildingTable[i].height;

		base = RetFloorLevel(p, true);
		if ( p.y < base )  p.y = base;
#else
		border.x = ((p.x-m_buildingTable[i].center.x)*m_buildingTable[i].max)/
				   dist+m_buildingTable[i].center.x;
		border.z = ((p.z-m_buildingTable[i].center.z)*m_buildingTable[i].max)/
				   dist+m_buildingTable[i].center.z;

		base = RetFloorLevel(border, true);

		p.y = (m_buildingTable[i].max-dist)/
			  (m_buildingTable[i].max-m_buildingTable[i].min)*
			  (m_buildingTable[i].level+m_buildingTable[i].height-base)+
			  base;
#endif
		return;
	}
}


// Returns the hardness of the ground in a given place.
// The hardness determines the noise (SOUND_STEP and SOUND_BOUM).

float CTerrain::RetHardness(const Math::Vector &p)
{
	TerrainMaterial*	tm;
	float				factor, dim;
	int					x, y, id;

	factor = RetBuildingFactor(p);
	if ( factor != 1.0f )  return 1.0f;  // on building

	if ( m_levelDot == 0 )  return m_defHardness;

	dim = (m_mosaic*m_brick*m_size)/2.0f;

	x = (int)((p.x+dim)/m_size);
	y = (int)((p.z+dim)/m_size);

	if ( x < 0 || x > m_mosaic*m_brick ||
		 y < 0 || y > m_mosaic*m_brick )  return m_defHardness;

	x /= m_brick/m_subdivMapping;
	y /= m_brick/m_subdivMapping;

	if ( x < 0 || x >= m_levelDotSize ||
		 y < 0 || y >= m_levelDotSize )  return m_defHardness;

	id = m_levelDot[x+y*m_levelDotSize].id;
	tm = LevelSearchMat(id);
	if ( tm == 0 )  return m_defHardness;

	return tm->hardness;
}


// Shows the flat areas on the ground.

void CTerrain::GroundFlat(Math::Vector pos)
{
	Math::Vector	p;
	float		rapport, angle;
	int			x, y, i;
	static char table[41*41];


	rapport = 3200.0f/1024.0f;

	for ( y=0 ; y<=40 ; y++ )
	{
		for ( x=0 ; x<=40 ; x++ )
		{
			i = x + y*41;
			table[i] = 0;

			p.x = (x-20)*rapport;
			p.z = (y-20)*rapport;
			p.y = 0.0f;
			if ( Math::Point(p.x, p.y).Length() > 20.0f*rapport )  continue;

			angle = RetFineSlope(pos+p);

			if ( angle < FLATLIMIT )
			{
				table[i] = 1;
			}
			else
			{
				table[i] = 2;
			}
		}
	}

	m_engine->GroundMarkCreate(pos, 40.0f, 0.001f, 15.0f, 0.001f, 41, 41, table);
}


// Calculates the radius of the largest flat area available.
// This calculation is not optimized!

float CTerrain::RetFlatZoneRadius(Math::Vector center, float max)
{
	Math::Vector	pos;
	Math::Point		c, p;
	float		ref, radius, angle, h;
	int			i, nb;

	angle = RetFineSlope(center);
	if ( angle >= FLATLIMIT )  return 0.0f;

	ref = RetFloorLevel(center, true);

	radius = 1.0f;
	while ( radius <= max )
	{
		angle = 0.0f;
		nb = (int)(2.0f*Math::PI*radius);
		if ( nb < 8 )  nb = 8;
		for ( i=0 ; i<nb ; i++ )
		{
			c.x = center.x;
			c.y = center.z;
			p.x = center.x+radius;
			p.y = center.z;
			p = Math::RotatePoint(c, angle, p);
			pos.x = p.x;
			pos.z = p.y;
			h = RetFloorLevel(pos, true);
			if ( fabs(h-ref) > 1.0f )  return radius;

			angle += Math::PI*2.0f/8.0f;
		}
		radius += 1.0f;
	}
	return max;
}



// Specifies the maximum height of flight.

void CTerrain::SetFlyingMaxHeight(float height)
{
	m_flyingMaxHeight = height;
}

// Returns the maximum height of flight.

float CTerrain::RetFlyingMaxHeight()
{
	return m_flyingMaxHeight;
}


// Empty the limits table of flight.

void CTerrain::FlushFlyingLimit()
{
	m_flyingMaxHeight = 280.0f;
	m_flyingLimitTotal = 0;
}

// Empty the limits table of flight.

bool CTerrain::AddFlyingLimit(Math::Vector center,
							  float extRadius, float intRadius,
							  float maxHeight)
{
	int		i;

	if ( m_flyingLimitTotal >= MAXFLYINGLIMIT )  return false;

	i = m_flyingLimitTotal;
	m_flyingLimit[i].center    = center;
	m_flyingLimit[i].extRadius = extRadius;
	m_flyingLimit[i].intRadius = intRadius;
	m_flyingLimit[i].maxHeight = maxHeight;
	m_flyingLimitTotal = i+1;

	return true;
}

// Returns the maximum height of flight.

float CTerrain::RetFlyingLimit(Math::Vector pos, bool bNoLimit)
{
	float	dist, h;
	int		i;

	if ( bNoLimit )  return 280.0f;
	if ( m_flyingLimitTotal == 0 )  return m_flyingMaxHeight;

	for ( i=0 ; i<m_flyingLimitTotal ; i++ )
	{
		dist = Math::DistanceProjected(pos, m_flyingLimit[i].center);

		if ( dist >= m_flyingLimit[i].extRadius )  continue;

		if ( dist <= m_flyingLimit[i].intRadius )
		{
			return m_flyingLimit[i].maxHeight;
		}

		dist -= m_flyingLimit[i].intRadius;

		h = dist*(m_flyingMaxHeight-m_flyingLimit[i].maxHeight)/
			(m_flyingLimit[i].extRadius-m_flyingLimit[i].intRadius);

		return h + m_flyingLimit[i].maxHeight;
	}

	return m_flyingMaxHeight;
}