1

/* $Id$ */

     2

     3

/** @file random_func.hpp */

     4

     5

#ifndef RANDOM_FUNC_HPP

     6

#define RANDOM_FUNC_HPP

     7

     8

#if defined(__APPLE__)

     9

	/* Apple already has Random declared */

    10

	#define Random OTTD_Random

    11

#endif /* __APPLE__ */

    12

    13

/**************

    14

 * Warning: DO NOT enable this unless you understand what it does

    15

 *

    16

 * If enabled, in a network game all randoms will be dumped to the

    17

 *  stdout if the first client joins (or if you are a client). This

    18

 *  is to help finding desync problems.

    19

 *

    20

 * Warning: DO NOT enable this unless you understand what it does

    21

 **************/

    22

    23

//#define RANDOM_DEBUG

    24

    25

    26

// Enable this to produce higher quality random numbers.

    27

// Doesn't work with network yet.

    28

// #define MERSENNE_TWISTER

    29

    30

/**

    31

 * Structure to encapsulate the pseudo random number generators.

    32

 */

    33

struct Randomizer {

    34

	/** The state of the randomizer */

    35

	uint32 state[2];

    36

    37

	/**

    38

	 * Generate the next pseudo random number

    39

	 * @return the random number

    40

	 */

    41

	uint32 Next();

    42

    43

	/**

    44

	 * Generate the next pseudo random number scaled to max

    45

	 * @param max the maximum value of the returned random number

    46

	 * @return the random number

    47

	 */

    48

	uint32 Next(uint16 max);

    49

    50

	/**

    51

	 * (Re)set the state of the random number generator.

    52

	 * @param seed the new state

    53

	 */

    54

	void SetSeed(uint32 seed);

    55

};

    56

extern Randomizer _random; ///< Random used in the game state calculations

    57

extern Randomizer _interactive_random; ///< Random used every else where is does not (directly) influence the game state

    58

    59

void SetRandomSeed(uint32 seed);

    60

#ifdef RANDOM_DEBUG

    61

	#define Random() DoRandom(__LINE__, __FILE__)

    62

	uint32 DoRandom(int line, const char *file);

    63

	#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)

    64

	uint DoRandomRange(uint max, int line, const char *file);

    65

#else

    66

	static inline uint32 Random() { return _random.Next(); }

    67

	static inline uint32 RandomRange(uint16 max) { return _random.Next(max); }

    68

#endif

    69

    70

static inline uint32 InteractiveRandom() { return _interactive_random.Next(); }

    71

static inline uint32 InteractiveRandomRange(uint16 max) { return _interactive_random.Next(max); }

    72

    73

/**

    74

 * Checks if a given randomize-number is below a given probability.

    75

 *

    76

 * This function is used to check if the given probability by the fraction of (a/b)

    77

 * is greater than low 16 bits of the given randomize-number v.

    78

 *

    79

 * Do not use this function twice on the same random 16 bits as it will yield

    80

 * the same result. One can use a random number for two calls to Chance16I,

    81

 * where one call sends the low 16 bits and the other the high 16 bits.

    82

 *

    83

 * @param a The numerator of the fraction

    84

 * @param b The denominator of the fraction, must of course not be null

    85

 * @param r The given randomize-number

    86

 * @return True if v is less or equals (a/b)

    87

 */

    88

static inline bool Chance16I(const uint a, const uint b, const uint32 r)

    89

{

    90

	assert(b != 0);

    91

	return (uint16)r < (uint16)(((a << 16) + b / 2) / b);

    92

}

    93

    94

/**

    95

 * Flips a coin with a given probability.

    96

 *

    97

 * This macro can be used to get true or false randomized according to a

    98

 * given probability. The parameter a and b create a percent value with

    99

 * (a/b). The macro returns true in (a/b) percent.

   100

 *

   101

 * @see Chance16I()

   102

 * @param a The numerator of the fraction

   103

 * @param b The denominator of the fraction

   104

 * @return True in (a/b) percent

   105

 */

   106

static inline bool Chance16(const uint a, const uint b)

   107

{

   108

	return Chance16I(a, b, Random());

   109

}

   110

   111

/**

   112

 * Flips a coin with a given probability and saves the randomize-number in a variable.

   113

 *

   114

 * This function uses the same parameters as Chance16. The third parameter

   115

 * must be a variable the randomize-number from Random() is saved in.

   116

 *

   117

 * The low 16 bits of r will already be used and can therefor not be passed to

   118

 * Chance16I. One can only send the high 16 bits to Chance16I.

   119

 *

   120

 * @see Chance16I()

   121

 * @param a The numerator of the fraction

   122

 * @param b The denominator of the fraction

   123

 * @param r The variable to save the randomize-number from Random()

   124

 * @return True in (a/b) percent

   125

 */

   126

static inline bool Chance16R(const uint a, const uint b, uint32 &r)

   127

{

   128

	r = Random();

   129

	return Chance16I(a, b, r);

   130

}

   131

   132

#endif /* RANDOM_FUNC_HPP */