1

/* $Id$ */

     2

     3

/**

     4

 * @file economy_new.h

     5

 * Definition file for the economy of the game.

     6

 */

     7

     8

#ifndef ECONOMY_NEW_H

     9

#define ECONOMY_NEW_H

    10

    11

#include "debug.h"          // debug outputs

    12

#include "fixedt.h"         // FixedT data types

    13

#include "date.h"           // current year / date

    14

#include "variables.h"      // difficulty

    15

#include "functions.h"      // RandomRange

    16

#include "saveload.h"       // Saveload stuff

    17

    18

/**

    19

 * A Base Class used for economic entities in the game that use an activity level.

    20

 */

    21

class EconomicObject {

    22

protected:

    23

	FixedT<int64, 16> m_activity_level;   ///< Economic Activity Level, an indicator for the GDP per capita of the map

    24

    25

public:

    26

	/**

    27

	 * Destructors for EconomicObjects. It is virtual because at least one of the methods

    28

	 * (or member functions) is virtual; thus a non-virtual destructor will cause a

    29

	 * compiler warning

    30

	 */

    31

	virtual ~EconomicObject() {}

    32

    33

	/**

    34

	 * Used to set the activity level from outside

    35

	 */

    36

	virtual void SetActivity() {}

    37

    38

	/**

    39

	 * Obtains the activity level of the object

    40

	 * @return the economic activity

    41

	 */

    42

	FixedT<int64, 16> GetActivity() const { return m_activity_level; }

    43

};

    44

    45

/**

    46

 * Handles all the economic data and events

    47

 */

    48

class CEconomy : public EconomicObject {

    49

public:

    50

	/**

    51

	 * Enumerator for the different costs for operations a player can perform.

    52

	 * Should be used to access the array of prices.

    53

	 */

    54

	enum Price {

    55

		STATION_VALUE,

    56

		PRICE_RAIL_BUILD,      /**< Cost of placing a single piece of track (a vertical or horizontal one.

    57

								 *  @todo make sure the longer pieces of track cost a bit more

    58

								 */

    59

		BUILD_ROAD,

    60

		BUILD_SIGNALS,

    61

		BUILD_BRIDGE,

    62

		BUILD_TRAIN_DEPOT,

    63

		BUILD_ROAD_DEPOT,

    64

		BUILD_SHIP_DEPOT,

    65

		BUILD_TUNNEL,

    66

		TRAIN_STATION_TRACK,

    67

		TRAIN_STATION_LENGTH,

    68

		BUILD_AIRPORT,

    69

		BUILD_BUS_STATION,

    70

		BUILD_TRUCK_STATION,

    71

		BUILD_DOCK,

    72

		BUILD_RAILVEHICLE,

    73

		BUILD_RAILWAGON,

    74

		AIRCRAFT_BASE,

    75

		ROADVEH_BASE,

    76

		SHIP_BASE,

    77

		BUILD_TREES,

    78

		TERRAFORM,

    79

		CLEAR_1,

    80

		PURCHASE_LAND,

    81

		CLEAR_2,

    82

		CLEAR_3,

    83

		REMOVE_TREES,

    84

		PRICE_RAIL_REMOVE,     /**< cost for removing a piece of track. Less than for building because one

    85

								 *  might be able to reuse stuff

    86

						 		 */

    87

		REMOVE_SIGNALS,

    88

		CLEAR_BRIDGE,

    89

		REMOVE_TRAIN_DEPOT,

    90

		REMOVE_ROAD_DEPOT,

    91

		REMOVE_SHIP_DEPOT,

    92

		CLEAR_TUNNEL,

    93

		CLEAR_WATER,

    94

		REMOVE_RAIL_STATION,

    95

		REMOVE_AIRPORT,

    96

		REMOVE_BUS_STATION,

    97

		REMOVE_TRUCK_STATION,

    98

		REMOVE_DOCK,

    99

		REMOVE_HOUSE,

   100

		REMOVE_ROAD,

   101

		RUNNING_RAIL0,

   102

		RUNNING_RAIL1,

   103

		RUNNING_RAIL2,

   104

		AIRCRAFT_RUNNING,

   105

		ROADVEH_RUNNING,

   106

		SHIP_RUNNING,

   107

		BUILD_INDUSTRY,

   108

   109

		MAX_PRICE              ///< end marker; use with for loops and arrays for example

   110

	};

   111

   112

   113

private:

   114

	FixedT<int32, 16> m_basic_growth;                 ///< Basic growth number, depends solely on difficulty setting

   115

	byte              m_long_term_cycle;              ///< The period of the long-term cycle suggested by Kondratiev

   116

	byte              m_short_term_cycle;             ///< The period of the short-term cycle (see Juglar, others)

   117

	FixedT<int32, 16> m_long_term_ampl;               ///< Amplitude of the long-term cycle

   118

	FixedT<int32, 16> m_short_term_ampl;              ///< Amplitude of the short-term cycle

   119

   120

	FixedT<int32, 16> m_prices[MAX_PRICE];            ///< Cost of operations for the player. Positive for cost, negative for income

   121

   122

public:

   123

	CEconomy();

   124

   125

	/**

   126

	 * Removes an economy.

   127

	 */

   128

	~CEconomy() {

   129

		DEBUG(eco, 3, "Ending economy");

   130

	}

   131

   132

	/**

   133

	 * Adjusts the economic settings on a yearly level.

   134

	 */

   135

	void YearlyLoop()

   136

	{

   137

		FixedT<int32, 16> growth = m_basic_growth;

   138

		growth += GetCyclicGrowth();

   139

		DEBUG(eco, 3, "Entering the yearly loop for economy");

   140

		m_activity_level *= growth;

   141

		DEBUG(eco, 4, "Set global EAL to %.3f", (double)m_activity_level);

   142

	}

   143

   144

	/**

   145

	 * Adds random events to the economic growth. This should call a random event every

   146

	 * 20 months. Well at least it should if RandomRange would be distributed in a

   147

	 * linear fashion. Note that there's one event in RandomEvents with a value of

   148

	 * -100 that doesn't have a positive "partner". This one simulates a big crash

   149

	 * or any other catastrohic event (war, disease, terrorism, whatever).

   150

	 * @todo Add news events for higher modifications in the economy (=> 2%)

   151

	 */

   152

	void MonthlyLoop()

   153

	{

   154

		AdjustActivityByTowns();

   155

		/* Modifications of the global economic activity one-tenth of a percent */

   156

		static const int RandomEvents[] = {-1, 1, -2, 2, -5, 5, -10, 10, -12, 12, -15, 15, -20, 20, -25, 25, 32, -32, 50, -50, -100};

   157

		/* I didn't use the 19, because it hardly ever is the return of RandomRange for whatever reason */

   158

		if (RandomRange(20) != 18) return;

   159

   160

		FixedT<int32, 16> mod( RandomEvents[RandomRange(lengthof(RandomEvents))], 1000);

   161

		mod += 1;

   162

   163

		m_activity_level *= mod;

   164

		DEBUG(eco, 5, "Added a random event with a value of %f, adjusted EAL to %f", (double)mod, (double)m_activity_level);

   165

   166

	}

   167

   168

	void AdjustActivityByTowns();

   169

   170

	static const SaveLoad eco_desc[];

   171

   172

	/**

   173

	 * Saves and Loads the prices from the savegame

   174

	 */

   175

	void SaveLoad_PRIC()

   176

	{

   177

		uint16 dummy[MAX_PRICE];

   178

		SlArray(m_prices, MAX_PRICE, SLE_INT32);

   179

		SlArray(dummy, MAX_PRICE, SLE_UINT16);

   180

	}

   181

   182

	int32 GetPrice(Price operation, TileIndex tile = INVALID_TILE, bool release = false) const;

   183

   184

	/**

   185

	 * Manually sets the price of an operation, used while loading games

   186

	 * @param operation The operation which to set the price for

   187

	 * @param value     The new price of the operation

   188

	 */

   189

	void SetPrice(int operation, int32 value)

   190

	{

   191

		assert(operation < MAX_PRICE);

   192

		DEBUG(eco, 4, "Setting price of operation %d to %f", (int)operation, (double) value);

   193

		m_prices[operation] = value;

   194

	}

   195

   196

private:

   197

	/**

   198

	 * Computes the modification of economic growth by cyclic events

   199

	 * @return The growth modification

   200

	 */

   201

	FixedT<int32, 16> GetCyclicGrowth() const

   202

	{

   203

		FixedT<int32, 16> long_term (PI * 2 * (_cur_year - 1800), m_long_term_cycle);

   204

		FixedT<int32, 16> short_term(PI * 2 * (_cur_year - 1800), m_short_term_cycle);

   205

   206

		DEBUG(eco, 5, "Cyclic Growth is %.4f", (double)(m_long_term_ampl * cos(long_term) + m_short_term_ampl * cos(short_term)));

   207

		return (  m_long_term_ampl * cos(long_term) + m_short_term_ampl * cos(short_term) );

   208

	}

   209

};

   210

   211

   212

extern CEconomy *_eco;

   213

void InitializeEconomy();

   214

   215

#endif /* ECONOMY_NEW_H */