1

/* $Id$ */

     2

     3

/** @file genworld.h */

     4

     5

#ifndef GENWORLD_H

     6

#define GENWORLD_H

     7

     8

/* If OTTDThread isn't defined, define it to a void, but make sure to undefine

     9

 *  it after this include. This makes including genworld.h easier, as you

    10

 *  don't need to include thread.h before it, while it stays possible to

    11

 *  include it after it, and still work.

    12

 */

    13

#ifndef OTTDThread

    14

#define TEMPORARY_OTTDTHREAD_DEFINITION

    15

#define OTTDThread void

    16

#endif

    17

    18

#include "player_type.h"

    19

    20

/*

    21

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

    22

 * Otherwise you will get inconsistent behaviour.

    23

 */

    24

enum {

    25

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

    26

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

    27

    28

	GENERATE_NEW_SEED = (uint)-1, ///< Create a new random seed

    29

};

    30

    31

typedef void gw_done_proc();

    32

typedef void gw_abort_proc();

    33

    34

struct gw_info {

    35

	bool active;           ///< Is generating world active

    36

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

    37

	bool wait_for_draw;    ///< Are we waiting on a draw event

    38

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

    39

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

    40

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

    41

	PlayerID lp;           ///< The local_player before generating

    42

	uint size_x;           ///< X-size of the map

    43

	uint size_y;           ///< Y-size of the map

    44

	gw_done_proc *proc;    ///< Proc that is called when done (can be NULL)

    45

	gw_abort_proc *abortp; ///< Proc that is called when aborting (can be NULL)

    46

	OTTDThread *thread;    ///< The thread we are in (can be NULL)

    47

};

    48

    49

#ifdef TEMPORARY_OTTDTHREAD_DEFINITION

    50

#undef OTTDThread

    51

#undef TEMPORARY_OTTDTHREAD_DEFINITION

    52

#endif

    53

    54

enum gwp_class {

    55

	GWP_MAP_INIT,    ///< Initialize/allocate the map, start economy

    56

	GWP_LANDSCAPE,   ///< Create the landscape

    57

	GWP_ROUGH_ROCKY, ///< Make rough and rocky areas

    58

	GWP_TOWN,        ///< Generate towns

    59

	GWP_INDUSTRY,    ///< Generate industries

    60

	GWP_UNMOVABLE,   ///< Generate unmovables (radio tower, light houses)

    61

	GWP_TREE,        ///< Generate trees

    62

	GWP_GAME_INIT,   ///< Initialize the game

    63

	GWP_RUNTILELOOP, ///< Runs the tile loop 1280 times to make snow etc

    64

	GWP_GAME_START,  ///< Really prepare to start the game

    65

	GWP_CLASS_COUNT

    66

};

    67

    68

/**

    69

 * Check if we are currently in the process of generating a world.

    70

 */

    71

static inline bool IsGeneratingWorld()

    72

{

    73

	extern gw_info _gw;

    74

    75

	return _gw.active;

    76

}

    77

    78

/* genworld.cpp */

    79

void SetGeneratingWorldPaintStatus(bool status);

    80

bool IsGeneratingWorldReadyForPaint();

    81

bool IsGenerateWorldThreaded();

    82

void GenerateWorldSetCallback(gw_done_proc *proc);

    83

void GenerateWorldSetAbortCallback(gw_abort_proc *proc);

    84

void WaitTillGeneratedWorld();

    85

void GenerateWorld(int mode, uint size_x, uint size_y);

    86

void AbortGeneratingWorld();

    87

bool IsGeneratingWorldAborted();

    88

void HandleGeneratingWorldAbortion();

    89

    90

/* genworld_gui.cpp */

    91

void SetGeneratingWorldProgress(gwp_class cls, uint total);

    92

void IncreaseGeneratingWorldProgress(gwp_class cls);

    93

void PrepareGenerateWorldProgress();

    94

void ShowGenerateWorldProgress();

    95

void StartNewGameWithoutGUI(uint seed);

    96

void ShowCreateScenario();

    97

void StartScenarioEditor();

    98

    99

#endif /* GENWORLD_H */