/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD 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, version 2.

 * OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

/** @file genworld.h Functions related to world/map generation. */

#ifndef GENWORLD_H

#define GENWORLD_H

#include "company_type.h"

/** Constants related to world generation */

enum LandscapeGenerator {

	/* Order of these enums has to be the same as in lang/english.txt

	 * Otherwise you will get inconsistent behaviour. */

	LG_ORIGINAL     = 0,  ///< The original landscape generator

	LG_TERRAGENESIS = 1,  ///< TerraGenesis Perlin landscape generator

};

/** Modes for GenerateWorld */

enum GenWorldMode {

	GWM_NEWGAME   = 0, ///< Generate a map for a new game

	GWM_EMPTY     = 1, ///< Generate an empty map (sea-level)

	GWM_RANDOM    = 2, ///< Generate a random map for SE

	GWM_HEIGHTMAP = 3, ///< Generate a newgame from a heightmap

};

static const uint CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY = 4; ///< Value for custom sea level in difficulty settings.

static const uint CUSTOM_SEA_LEVEL_MIN_PERCENTAGE = 1;    ///< Minimum percentage a user can specify for custom sea level.

static const uint CUSTOM_SEA_LEVEL_MAX_PERCENTAGE = 90;   ///< Maximum percentage a user can specify for custom sea level.

typedef void GWDoneProc();  ///< Procedure called when the genworld process finishes

typedef void GWAbortProc(); ///< Called when genworld is aborted

/** Properties of current genworld process */

struct GenWorldInfo {

	bool active;           ///< Is generating world active

	bool abort;            ///< Whether to abort the thread ASAP

	bool quit_thread;      ///< Do we want to quit the active thread

	bool threaded;         ///< Whether we run _GenerateWorld threaded

	GenWorldMode mode;     ///< What mode are we making a world in

	CompanyID lc;          ///< The local_company before generating

static void _SetGeneratingWorldProgress(GenWorldProgress cls, uint progress, uint total)

{

	static const int percent_table[] = {0, 5, 14, 17, 20, 40, 60, 65, 80, 85, 99, 100 };

	assert_compile(lengthof(percent_table) == GWP_CLASS_COUNT + 1);

	assert(cls < GWP_CLASS_COUNT);

	/* Do not run this function if we aren't in a thread */

	if (!IsGenerateWorldThreaded() && !_network_dedicated) return;

	if (IsGeneratingWorldAborted()) HandleGeneratingWorldAbortion();

	if (total == 0) {

		assert(_gws.cls == _generation_class_table[cls]);

		_gws.current += progress;

		assert(_gws.current <= _gws.total);

	} else {

		_gws.cls     = _generation_class_table[cls];

		_gws.current = progress;

		_gws.total   = total;

		_gws.percent = percent_table[cls];

	}

	/* Don't update the screen too often. So update it once in every once in a while... */

	/* Percentage is about the number of completed tasks, so 'current - 1' */

	_gws.percent = percent_table[cls] + (percent_table[cls + 1] - percent_table[cls]) * (_gws.current == 0 ? 0 : _gws.current - 1) / _gws.total;

	if (_network_dedicated) {

		static uint last_percent = 0;

		/* Never display 0% */

		if (_gws.percent == 0) return;

		/* Reset if percent is lower than the last recorded */

		if (_gws.percent < last_percent) last_percent = 0;

		/* Display every 5%, but 6% is also very valid.. just not smaller steps than 5% */

		if (_gws.percent % 5 != 0 && _gws.percent <= last_percent + 5) return;

		/* Never show steps smaller than 2%, even if it is a mod 5% */

		if (_gws.percent <= last_percent + 2) return;

		DEBUG(net, 1, "Map generation percentage complete: %d", _gws.percent);

		last_percent = _gws.percent;

		/* Don't continue as dedicated never has a thread running */

		return;

	}

	SetWindowDirty(WC_GENERATE_PROGRESS_WINDOW, 0);

	_video_driver->MakeDirty(left, top, right - left, bottom - top);

}

/**

 * Repaints the rectangle blocks which are marked as 'dirty'.

 *

 * @see SetDirtyBlocks

 */

void DrawDirtyBlocks()

{

	byte *b = _dirty_blocks;

	const int w = Align(_screen.width,  DIRTY_BLOCK_WIDTH);

	const int h = Align(_screen.height, DIRTY_BLOCK_HEIGHT);

	int x;

	int y;

	if (HasModalProgress()) {

		/* We are generating the world, so release our rights to the map and

		 * painting while we are waiting a bit. */

		_modal_progress_paint_mutex->EndCritical();

		_modal_progress_work_mutex->EndCritical();

		/* Wait a while and update _realtime_tick so we are given the rights */

		_modal_progress_paint_mutex->BeginCritical();

		_modal_progress_work_mutex->BeginCritical();

	}

	y = 0;

	do {

		x = 0;

		do {

			if (*b != 0) {

				int left;

				int top;

				int right = x + DIRTY_BLOCK_WIDTH;

				int bottom = y;

				byte *p = b;

				int h2;

				/* First try coalescing downwards */

				do {

					*p = 0;

					p += _dirty_bytes_per_line;

					bottom += DIRTY_BLOCK_HEIGHT;

				} while (bottom != h && *p != 0);

				/* Try coalescing to the right too. */