1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/* $Id$ */
/** @file random_func.hpp Pseudo random number generator. */
#ifndef RANDOM_FUNC_HPP
#define RANDOM_FUNC_HPP
#if defined(__APPLE__)
/* Apple already has Random declared */
#define Random OTTD_Random
#endif /* __APPLE__ */
/**************
* Warning: DO NOT enable this unless you understand what it does
*
* If enabled, in a network game all randoms will be dumped to the
* stdout if the first client joins (or if you are a client). This
* is to help finding desync problems.
*
* Warning: DO NOT enable this unless you understand what it does
**************/
//#define RANDOM_DEBUG
/**
* Structure to encapsulate the pseudo random number generators.
*/
struct Randomizer {
/** The state of the randomizer */
uint32 state[2];
/**
* Generate the next pseudo random number
* @return the random number
*/
uint32 Next();
/**
* Generate the next pseudo random number scaled to max
* @param max the maximum value of the returned random number
* @return the random number
*/
uint32 Next(uint16 max);
/**
* (Re)set the state of the random number generator.
* @param seed the new state
*/
void SetSeed(uint32 seed);
};
extern Randomizer _random; ///< Random used in the game state calculations
extern Randomizer _interactive_random; ///< Random used every else where is does not (directly) influence the game state
/** Stores the state of all random number generators */
struct SavedRandomSeeds {
Randomizer random;
Randomizer interactive_random;
};
/** Saves the current seeds
* @param storage Storage for saving
*/
static inline void SaveRandomSeeds(SavedRandomSeeds *storage)
{
storage->random = _random;
storage->interactive_random = _interactive_random;
}
/** Restores previously saved seeds
* @param storage Storage where SaveRandomSeeds() stored th seeds
*/
static inline void RestoreRandomSeeds(const SavedRandomSeeds &storage)
{
_random = storage.random;
_interactive_random = storage.interactive_random;
}
void SetRandomSeed(uint32 seed);
#ifdef RANDOM_DEBUG
#define Random() DoRandom(__LINE__, __FILE__)
uint32 DoRandom(int line, const char *file);
#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)
uint DoRandomRange(uint max, int line, const char *file);
#else
static FORCEINLINE uint32 Random()
{
return _random.Next();
}
static FORCEINLINE uint32 RandomRange(uint16 max)
{
return _random.Next(max);
}
#endif
static FORCEINLINE uint32 InteractiveRandom()
{
return _interactive_random.Next();
}
static FORCEINLINE uint32 InteractiveRandomRange(uint16 max)
{
return _interactive_random.Next(max);
}
/**
* Checks if a given randomize-number is below a given probability.
*
* This function is used to check if the given probability by the fraction of (a/b)
* is greater than low 16 bits of the given randomize-number v.
*
* Do not use this function twice on the same random 16 bits as it will yield
* the same result. One can use a random number for two calls to Chance16I,
* where one call sends the low 16 bits and the other the high 16 bits.
*
* @param a The numerator of the fraction
* @param b The denominator of the fraction, must of course not be null
* @param r The given randomize-number
* @return True if v is less or equals (a/b)
*/
static FORCEINLINE bool Chance16I(const uint a, const uint b, const uint32 r)
{
assert(b != 0);
return (uint16)r < (uint16)(((a << 16) + b / 2) / b);
}
/**
* Flips a coin with a given probability.
*
* This macro can be used to get true or false randomized according to a
* given probability. The parameter a and b create a percent value with
* (a/b). The macro returns true in (a/b) percent.
*
* @see Chance16I()
* @param a The numerator of the fraction
* @param b The denominator of the fraction
* @return True in (a/b) percent
*/
static FORCEINLINE bool Chance16(const uint a, const uint b)
{
return Chance16I(a, b, Random());
}
/**
* Flips a coin with a given probability and saves the randomize-number in a variable.
*
* This function uses the same parameters as Chance16. The third parameter
* must be a variable the randomize-number from Random() is saved in.
*
* The low 16 bits of r will already be used and can therefor not be passed to
* Chance16I. One can only send the high 16 bits to Chance16I.
*
* @see Chance16I()
* @param a The numerator of the fraction
* @param b The denominator of the fraction
* @param r The variable to save the randomize-number from Random()
* @return True in (a/b) percent
*/
static FORCEINLINE bool Chance16R(const uint a, const uint b, uint32 &r)
{
r = Random();
return Chance16I(a, b, r);
}
#endif /* RANDOM_FUNC_HPP */
|
