1

/* $Id$ */

     2

     3

/** @file random_func.cpp */

     4

     5

#include "../stdafx.h"

     6

#include "../macros.h"

     7

#include "../variables.h"

     8

#include "random_func.hpp"

     9

    10

uint32 InteractiveRandom()

    11

{

    12

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

    13

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

    14

    15

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

    16

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

    17

}

    18

    19

uint InteractiveRandomRange(uint max)

    20

{

    21

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

    22

}

    23

    24

#ifdef MERSENNE_TWISTER

    25

// Source code for Mersenne Twister.

    26

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

    27

    28

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

    29

#define M              (397)                 // a period parameter

    30

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

    31

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

    32

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

    33

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

    34

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

    35

    36

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

    37

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

    38

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

    39

    40

void SetRandomSeed(register uint32 seed)

    41

{

    42

	register uint32 *s = _mt_state;

    43

	_mt_left = 0;

    44

    45

	seed |= 1U;

    46

	seed &= 0xFFFFFFFFU;

    47

    48

	*s = seed;

    49

    50

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

    51

		seed *= 69069U;

    52

		*s++;

    53

		*s = seed & 0xFFFFFFFFU;

    54

	}

    55

}

    56

    57

static uint32 ReloadRandom()

    58

{

    59

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

    60

    61

	_mt_left = N - 1;

    62

	_mt_next = _mt_state + 1;

    63

    64

	register uint32 *p0 = _mt_state;

    65

	register uint32 *p2 = _mt_state + 2;

    66

	register uint32 *pM = _mt_state + M;

    67

    68

	register uint32 s0 = _mt_state[0];

    69

	register uint32 s1 = _mt_state[1];

    70

    71

	register uint i = 0;

    72

    73

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

    74

		s0 = s1;

    75

		s1 = *p2;

    76

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

    77

		*p0++;

    78

		*p2++;

    79

		*pM++;

    80

	}

    81

    82

	pM = _mt_state;

    83

    84

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

    85

		s0 = s1;

    86

		s1 = *p2;

    87

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

    88

		*p0++;

    89

		*p2++;

    90

		*pM++;

    91

	}

    92

    93

	s1 = _mt_state[0];

    94

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

    95

    96

	s1 ^= (s1 >> 11);

    97

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

    98

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

    99

	s1 ^= (s1 >> 18);

   100

	return s1;

   101

}

   102

   103

uint32 Random()

   104

{

   105

	_mt_left--;

   106

	if (_mt_left < 0) return ReloadRandom();

   107

   108

	uint32 y = *_mt_next;

   109

	*_mt_next++;

   110

   111

	y ^= (y >> 11);

   112

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

   113

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

   114

	y ^= (y >> 18);

   115

	return y;

   116

}

   117

   118

#else /* MERSENNE_TWISTER */

   119

void SetRandomSeed(uint32 seed)

   120

{

   121

	_random_seeds[0][0] = seed;

   122

	_random_seeds[0][1] = seed;

   123

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

   124

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

   125

}

   126

   127

#ifdef RANDOM_DEBUG

   128

#include "network/network_data.h"

   129

uint32 DoRandom(int line, const char *file)

   130

{

   131

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

   132

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

   133

#else /* RANDOM_DEBUG */

   134

uint32 Random()

   135

{

   136

#endif /* RANDOM_DEBUG */

   137

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

   138

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

   139

   140

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

   141

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

   142

}

   143

#endif /* MERSENNE_TWISTER */

   144

   145

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

   146

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

   147

{

   148

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

   149

}

   150

#else /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   151

uint RandomRange(uint max)

   152

{

   153

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

   154

}

   155

#endif /* RANDOM_DEBUG & !MERSENNE_TWISTER */