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 */

   156

/* $Id$ */

   157

   158

/** @file random_func.cpp */

   159

   160

#include "../stdafx.h"

   161

#include "../macros.h"

   162

#include "../variables.h"

   163

#include "random_func.hpp"

   164

   165

uint32 InteractiveRandom()

   166

{

   167

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

   168

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

   169

   170

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

   171

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

   172

}

   173

   174

uint InteractiveRandomRange(uint max)

   175

{

   176

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

   177

}

   178

   179

#ifdef MERSENNE_TWISTER

   180

// Source code for Mersenne Twister.

   181

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

   182

   183

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

   184

#define M              (397)                 // a period parameter

   185

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

   186

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

   187

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

   188

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

   189

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

   190

   191

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

   192

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

   193

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

   194

   195

void SetRandomSeed(register uint32 seed)

   196

{

   197

	register uint32 *s = _mt_state;

   198

	_mt_left = 0;

   199

   200

	seed |= 1U;

   201

	seed &= 0xFFFFFFFFU;

   202

   203

	*s = seed;

   204

   205

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

   206

		seed *= 69069U;

   207

		*s++;

   208

		*s = seed & 0xFFFFFFFFU;

   209

	}

   210

}

   211

   212

static uint32 ReloadRandom()

   213

{

   214

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

   215

   216

	_mt_left = N - 1;

   217

	_mt_next = _mt_state + 1;

   218

   219

	register uint32 *p0 = _mt_state;

   220

	register uint32 *p2 = _mt_state + 2;

   221

	register uint32 *pM = _mt_state + M;

   222

   223

	register uint32 s0 = _mt_state[0];

   224

	register uint32 s1 = _mt_state[1];

   225

   226

	register uint i = 0;

   227

   228

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

   229

		s0 = s1;

   230

		s1 = *p2;

   231

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

   232

		*p0++;

   233

		*p2++;

   234

		*pM++;

   235

	}

   236

   237

	pM = _mt_state;

   238

   239

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

   240

		s0 = s1;

   241

		s1 = *p2;

   242

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

   243

		*p0++;

   244

		*p2++;

   245

		*pM++;

   246

	}

   247

   248

	s1 = _mt_state[0];

   249

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

   250

   251

	s1 ^= (s1 >> 11);

   252

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

   253

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

   254

	s1 ^= (s1 >> 18);

   255

	return s1;

   256

}

   257

   258

uint32 Random()

   259

{

   260

	_mt_left--;

   261

	if (_mt_left < 0) return ReloadRandom();

   262

   263

	uint32 y = *_mt_next;

   264

	*_mt_next++;

   265

   266

	y ^= (y >> 11);

   267

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

   268

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

   269

	y ^= (y >> 18);

   270

	return y;

   271

}

   272

   273

#else /* MERSENNE_TWISTER */

   274

void SetRandomSeed(uint32 seed)

   275

{

   276

	_random_seeds[0][0] = seed;

   277

	_random_seeds[0][1] = seed;

   278

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

   279

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

   280

}

   281

   282

#ifdef RANDOM_DEBUG

   283

#include "network/network_data.h"

   284

uint32 DoRandom(int line, const char *file)

   285

{

   286

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

   287

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

   288

#else /* RANDOM_DEBUG */

   289

uint32 Random()

   290

{

   291

#endif /* RANDOM_DEBUG */

   292

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

   293

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

   294

   295

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

   296

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

   297

}

   298

#endif /* MERSENNE_TWISTER */

   299

   300

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

   301

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

   302

{

   303

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

   304

}

   305

#else /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   306

uint RandomRange(uint max)

   307

{

   308

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

   309

}

   310

#endif /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   311

/* $Id$ */

   312

   313

/** @file random_func.cpp */

   314

   315

#include "../stdafx.h"

   316

#include "../macros.h"

   317

#include "../variables.h"

   318

#include "random_func.hpp"

   319

   320

uint32 InteractiveRandom()

   321

{

   322

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

   323

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

   324

   325

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

   326

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

   327

}

   328

   329

uint InteractiveRandomRange(uint max)

   330

{

   331

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

   332

}

   333

   334

#ifdef MERSENNE_TWISTER

   335

// Source code for Mersenne Twister.

   336

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

   337

   338

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

   339

#define M              (397)                 // a period parameter

   340

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

   341

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

   342

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

   343

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

   344

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

   345

   346

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

   347

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

   348

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

   349

   350

void SetRandomSeed(register uint32 seed)

   351

{

   352

	register uint32 *s = _mt_state;

   353

	_mt_left = 0;

   354

   355

	seed |= 1U;

   356

	seed &= 0xFFFFFFFFU;

   357

   358

	*s = seed;

   359

   360

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

   361

		seed *= 69069U;

   362

		*s++;

   363

		*s = seed & 0xFFFFFFFFU;

   364

	}

   365

}

   366

   367

static uint32 ReloadRandom()

   368

{

   369

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

   370

   371

	_mt_left = N - 1;

   372

	_mt_next = _mt_state + 1;

   373

   374

	register uint32 *p0 = _mt_state;

   375

	register uint32 *p2 = _mt_state + 2;

   376

	register uint32 *pM = _mt_state + M;

   377

   378

	register uint32 s0 = _mt_state[0];

   379

	register uint32 s1 = _mt_state[1];

   380

   381

	register uint i = 0;

   382

   383

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

   384

		s0 = s1;

   385

		s1 = *p2;

   386

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

   387

		*p0++;

   388

		*p2++;

   389

		*pM++;

   390

	}

   391

   392

	pM = _mt_state;

   393

   394

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

   395

		s0 = s1;

   396

		s1 = *p2;

   397

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

   398

		*p0++;

   399

		*p2++;

   400

		*pM++;

   401

	}

   402

   403

	s1 = _mt_state[0];

   404

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

   405

   406

	s1 ^= (s1 >> 11);

   407

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

   408

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

   409

	s1 ^= (s1 >> 18);

   410

	return s1;

   411

}

   412

   413

uint32 Random()

   414

{

   415

	_mt_left--;

   416

	if (_mt_left < 0) return ReloadRandom();

   417

   418

	uint32 y = *_mt_next;

   419

	*_mt_next++;

   420

   421

	y ^= (y >> 11);

   422

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

   423

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

   424

	y ^= (y >> 18);

   425

	return y;

   426

}

   427

   428

#else /* MERSENNE_TWISTER */

   429

void SetRandomSeed(uint32 seed)

   430

{

   431

	_random_seeds[0][0] = seed;

   432

	_random_seeds[0][1] = seed;

   433

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

   434

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

   435

}

   436

   437

#ifdef RANDOM_DEBUG

   438

#include "network/network_data.h"

   439

uint32 DoRandom(int line, const char *file)

   440

{

   441

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

   442

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

   443

#else /* RANDOM_DEBUG */

   444

uint32 Random()

   445

{

   446

#endif /* RANDOM_DEBUG */

   447

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

   448

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

   449

   450

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

   451

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

   452

}

   453

#endif /* MERSENNE_TWISTER */

   454

   455

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

   456

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

   457

{

   458

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

   459

}

   460

#else /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   461

uint RandomRange(uint max)

   462

{

   463

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

   464

}

   465

#endif /* RANDOM_DEBUG & !MERSENNE_TWISTER */

   466

/* $Id$ */

   467

   468

/** @file random_func.cpp */

   469

   470

#include "../stdafx.h"

   471

#include "../macros.h"

   472

#include "../variables.h"

   473

#include "random_func.hpp"

   474

   475

uint32 InteractiveRandom()

   476

{

   477

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

   478

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

   479

   480

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

   481

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

   482

}

   483

   484

uint InteractiveRandomRange(uint max)

   485

{

   486

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

   487

}

   488

   489

#ifdef MERSENNE_TWISTER

   490

// Source code for Mersenne Twister.

   491

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

   492

   493

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

   494

#define M              (397)                 // a period parameter

   495

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

   496

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

   497

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

   498

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

   499

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

   500

   501

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

   502

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

   503

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

   504

   505

void SetRandomSeed(register uint32 seed)

   506

{

   507

	register uint32 *s = _mt_state;

   508

	_mt_left = 0;

   509

   510

	seed |= 1U;

   511

	seed &= 0xFFFFFFFFU;

   512

   513

	*s = seed;

   514

   515

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

   516

		seed *= 69069U;

   517

		*s++;

   518

		*s = seed & 0xFFFFFFFFU;

   519

	}

   520

}

   521

   522

static uint32 ReloadRandom()

   523

{

   524

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

   525

   526

	_mt_left = N - 1;

   527

	_mt_next = _mt_state + 1;

   528

   529

	register uint32 *p0 = _mt_state;

   530