1

/* $Id$ */

     2

     3

/** @file random_func.hpp Pseudo random number generator. */

     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

/**

    27

 * Structure to encapsulate the pseudo random number generators.

    28

 */

    29

struct Randomizer {

    30

	/** The state of the randomizer */

    31

	uint32 state[2];

    32

    33

	/**

    34

	 * Generate the next pseudo random number

    35

	 * @return the random number

    36

	 */

    37

	uint32 Next();

    38

    39

	/**

    40

	 * Generate the next pseudo random number scaled to max

    41

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

    42

	 * @return the random number

    43

	 */

    44

	uint32 Next(uint16 max);

    45

    46

	/**

    47

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

    48

	 * @param seed the new state

    49

	 */

    50

	void SetSeed(uint32 seed);

    51

};

    52

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

    53

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

    54

    55

/** Stores the state of all random number generators */

    56

struct SavedRandomSeeds {

    57

	Randomizer random;

    58

	Randomizer interactive_random;

    59

};

    60

    61

/** Saves the current seeds

    62

 * @param storage Storage for saving

    63

 */

    64

static inline void SaveRandomSeeds(SavedRandomSeeds *storage)

    65

{

    66

	storage->random = _random;

    67

	storage->interactive_random = _interactive_random;

    68

}

    69

    70

/** Restores previously saved seeds

    71

 * @param storage Storage where SaveRandomSeeds() stored th seeds

    72

 */

    73

static inline void RestoreRandomSeeds(const SavedRandomSeeds &storage)

    74

{

    75

	_random = storage.random;

    76

	_interactive_random = storage.interactive_random;

    77

}

    78

    79

void SetRandomSeed(uint32 seed);

    80

#ifdef RANDOM_DEBUG

    81

	#define Random() DoRandom(__LINE__, __FILE__)

    82

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

    83

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

    84

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

    85

#else

    86

	static FORCEINLINE uint32 Random()

    87

	{

    88

		return _random.Next();

    89

	}

    90

    91

	static FORCEINLINE uint32 RandomRange(uint16 max)

    92

	{

    93

		return _random.Next(max);

    94

	}

    95

#endif

    96

    97

static FORCEINLINE uint32 InteractiveRandom()

    98

{

    99

	return _interactive_random.Next();

   100

}

   101

   102

static FORCEINLINE uint32 InteractiveRandomRange(uint16 max)

   103

{

   104

	return _interactive_random.Next(max);

   105

}

   106

   107

/**

   108

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

   109

 *

   110

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

   111

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

   112

 *

   113

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

   114

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

   115

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

   116

 *

   117

 * @param a The numerator of the fraction

   118

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

   119

 * @param r The given randomize-number

   120

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

   121

 */

   122

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

   123

{

   124

	assert(b != 0);

   125

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

   126

}

   127

   128

/**

   129

 * Flips a coin with a given probability.

   130

 *

   131

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

   132

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

   133

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

   134

 *

   135

 * @see Chance16I()

   136

 * @param a The numerator of the fraction

   137

 * @param b The denominator of the fraction

   138

 * @return True in (a/b) percent

   139

 */

   140

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

   141

{

   142

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

   143

}

   144

   145

/**

   146

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

   147

 *

   148

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

   149

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

   150

 *

   151

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

   152

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

   153

 *

   154

 * @see Chance16I()

   155

 * @param a The numerator of the fraction

   156

 * @param b The denominator of the fraction

   157

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

   158

 * @return True in (a/b) percent

   159

 */

   160

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

   161

{

   162

	r = Random();

   163

	return Chance16I(a, b, r);

   164

}

   165

   166

#endif /* RANDOM_FUNC_HPP */