1

/* $Id$ */

     2

     3

/** @file random_func.cpp */

     4

     5

#include "../stdafx.h"

     6

#include "random_func.hpp"

     7

#include "bitmath_func.hpp"

     8

     9

uint32 _random_seeds[2][2];

    10

    11

uint32 InteractiveRandom()

    12

{

    13

	const uint32 s = _random_seeds[1][0];

    14

	const uint32 t = _random_seeds[1][1];

    15

    16

	_random_seeds[1][0] = s + ROR(t ^ 0x1234567F, 7) + 1;

    17

	return _random_seeds[1][1] = ROR(s, 3) - 1;

    18

}

    19

    20

uint InteractiveRandomRange(uint max)

    21

{

    22

	return GB(InteractiveRandom(), 0, 16) * max >> 16;

    23

}

    24

    25

#ifdef MERSENNE_TWISTER

    26

// Source code for Mersenne Twister.

    27

// A Random number generator with much higher quality random numbers.

    28

    29

#define N              (624)                 // length of _mt_state vector

    30

#define M              (397)                 // a period parameter

    31

#define K              (0x9908B0DFU)         // a magic constant

    32

#define hiBit(u)       ((u) & 0x80000000U)   // mask all but highest   bit of u

    33

#define loBit(u)       ((u) & 0x00000001U)   // mask all but lowest    bit of u

    34

#define loBits(u)      ((u) & 0x7FFFFFFFU)   // mask     the highest   bit of u

    35

#define mixBits(u, v)  (hiBit(u)|loBits(v))  // move hi bit of u to hi bit of v

    36

    37

static uint32 _mt_state[N+1];     // _mt_state vector + 1 extra to not violate ANSI C

    38

static uint32 *_mt_next;          // _mt_next random value is computed from here

    39

static int    _mt_left = -1;      // can *_mt_next++ this many times before reloading

    40

    41

void SetRandomSeed(register uint32 seed)

    42

{

    43

	register uint32 *s = _mt_state;

    44

	_mt_left = 0;

    45

    46

	seed |= 1U;

    47

	seed &= 0xFFFFFFFFU;

    48

    49

	*s = seed;

    50

    51

	for (register uint i = N; i != 0; i--) {

    52

		seed *= 69069U;

    53

		*s++;

    54

		*s = seed & 0xFFFFFFFFU;

    55

	}

    56

}

    57

    58

static uint32 ReloadRandom()

    59

{

    60

	if (_mt_left < -1) SetRandomSeed(4357U);

    61

    62

	_mt_left = N - 1;

    63

	_mt_next = _mt_state + 1;

    64

    65

	register uint32 *p0 = _mt_state;

    66

	register uint32 *p2 = _mt_state + 2;

    67

	register uint32 *pM = _mt_state + M;

    68

    69

	register uint32 s0 = _mt_state[0];

    70

	register uint32 s1 = _mt_state[1];

    71

    72

	register uint i = 0;

    73

    74

	for (i = (N - M + 1); i != 0; i--) {

    75

		s0 = s1;

    76

		s1 = *p2;

    77

		*p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);

    78

		*p0++;

    79

		*p2++;

    80

		*pM++;

    81

	}

    82

    83

	pM = _mt_state;

    84

    85

	for (i = M; i != 0; i--) {

    86

		s0 = s1;

    87

		s1 = *p2;

    88

		*p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);

    89

		*p0++;

    90

		*p2++;

    91

		*pM++;

    92

	}

    93

    94

	s1 = _mt_state[0];

    95

	*p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);

    96

    97

	s1 ^= (s1 >> 11);

    98

	s1 ^= (s1 <<  7) & 0x9D2C5680U;

    99

	s1 ^= (s1 << 15) & 0xEFC60000U;

   100

	s1 ^= (s1 >> 18);

   101

	return s1;

   102

}

   103

   104

uint32 Random()

   105

{

   106

	_mt_left--;

   107

	if (_mt_left < 0) return ReloadRandom();

   108

   109

	uint32 y = *_mt_next;

   110

	*_mt_next++;

   111

   112

	y ^= (y >> 11);

   113

	y ^= (y <<  7) & 0x9D2C5680U;

   114

	y ^= (y << 15) & 0xEFC60000U;

   115

	y ^= (y >> 18);

   116

	return y;

   117

}

   118

   119

#else /* MERSENNE_TWISTER */

   120

void SetRandomSeed(uint32 seed)

   121

{

   122

	_random_seeds[0][0] = seed;

   123

	_random_seeds[0][1] = seed;

   124

	_random_seeds[1][0] = seed * 0x1234567;

   125

	_random_seeds[1][1] = _random_seeds[1][0];

   126

}

   127

   128

#ifdef RANDOM_DEBUG

   129

#include "../network/network_data.h"

   130

uint32 DoRandom(int line, const char *file)

   131

{

   132

	if (_networking && (DEREF_CLIENT(0)->status != STATUS_INACTIVE || !_network_server))

   133

		printf("Random [%d/%d] %s:%d\n",_frame_counter, (byte)_current_player, file, line);

   134

#else /* RANDOM_DEBUG */

   135

uint32 Random()

   136

{

   137

#endif /* RANDOM_DEBUG */

   138

	const uint32 s = _random_seeds[0][0];

   139

	const uint32 t = _random_seeds[0][1];

   140

   141

	_random_seeds[0][0] = s + ROR(t ^ 0x1234567F, 7) + 1;

   142

	return _random_seeds[0][1] = ROR(s, 3) - 1;

   143

}

   144

#endif /* MERSENNE_TWISTER */

   145

   146

#if defined(RANDOM_DEBUG) && !defined(MERSENNE_TWISTER)

   147

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

   148

{

   149

	return GB(DoRandom(line, file), 0, 16) * max >> 16;

   150

}

   151

#else /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   152

uint RandomRange(uint max)

   153

{

   154

	return GB(Random(), 0, 16) * max >> 16;

   155

}

   156

#endif /* RANDOM_DEBUG & !MERSENNE_TWISTER */