src/tools/tRandom.cpp

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

// declaration
#ifndef         TRANDOM_H_INCLUDED
#include        "tRandom.h"
#endif

#ifdef      HAVE_STDLIB
#include    <stdlib.h>
#endif

#include    "tError.h"
#include    "tRecorder.h"
#include    <cstdlib>

#undef  INLINE_DEF
#define INLINE_DEF

// *******************************************************************************************
// *
// *    tRandomizer
// *
// *******************************************************************************************
// *******************************************************************************************

tRandomizer::tRandomizer( void )
        :randMax_( RAND_MAX )
{
}

// *******************************************************************************************
// *
// *    Get
// *
// *******************************************************************************************
// *******************************************************************************************

REAL tRandomizer::Get( void )
{
    // Grr. VisualC 6 can't handle this in one line.
    REAL a = GetRawRand();
    REAL b = randMax_;

    return a / b;
}

// *******************************************************************************************
// *
// *    Get
// *
// *******************************************************************************************
// *******************************************************************************************

int tRandomizer::Get( int max )
{
    int ret = int( floorf( Get() * max ) );
    tASSERT( 0 <= ret );
    tASSERT( ret < max );

    return ret;
}

// *******************************************************************************************
// *
// *    GetInstance
// *
// *******************************************************************************************
// *******************************************************************************************

tRandomizer & tRandomizer::GetInstance( void )
{
    static tRandomizer randomizer;
    return randomizer;
}

// *******************************************************************************************
// *
// *    ~tRandomizer
// *
// *******************************************************************************************
// *******************************************************************************************

tRandomizer::~tRandomizer( void )
{
}

// *******************************************************************************************
// *
// *    tRandomizer
// *
// *******************************************************************************************
// *******************************************************************************************

tRandomizer::tRandomizer( tRandomizer const & other )
{
    tASSERT( 0 ); // not implemented
}

// *******************************************************************************************
// *
// *    operator =
// *
// *******************************************************************************************
// *******************************************************************************************

tRandomizer & tRandomizer::operator =( tRandomizer const & other )
{
    tASSERT( 0 ); // not implemented

    return *this;
}

// *******************************************************************************************
// *
// *    GetRawRand
// *
// *******************************************************************************************
// *******************************************************************************************

unsigned int tRandomizer::GetRawRand( void )
{
    return rand();
}

static char const * recordingSection = "RANDOM";

// *******************************************************************************************
// *
// *   tReproducibleRandomizer
// *
// *******************************************************************************************
// *******************************************************************************************

tReproducibleRandomizer::tReproducibleRandomizer( void )
{
    // generate random seeds with standard random generator
    z_ = rand();
    w_ = rand();
    randMax_ = 0xffffffff;

    // archive seed
    tRecorder::PlaybackStrict( recordingSection, z_ );
    tRecorder::Record( recordingSection, z_ );

    tRecorder::PlaybackStrict( recordingSection, w_ );
    tRecorder::Record( recordingSection, w_ );

    /*
        // read RAND_MAX from recording or write it to recording
        if ( !tRecorder::PlaybackStrict( recordingSection, randMax_ ) )
            tRecorder::Record( recordingSection, randMax_ );
    */
}

// *******************************************************************************************
// *
// *    ~tReproducibleRandomizer
// *
// *******************************************************************************************
// *******************************************************************************************

tReproducibleRandomizer::~tReproducibleRandomizer( void )
{
}

// *******************************************************************************************
// *
// *    GetInstance
// *
// *******************************************************************************************
// *******************************************************************************************

tReproducibleRandomizer & tReproducibleRandomizer::GetInstance( void )
{
    static tReproducibleRandomizer randomizer;
    return randomizer;
}

// *******************************************************************************************
// *
// *    GetRawRand
// *
// *******************************************************************************************
// *******************************************************************************************

unsigned int tReproducibleRandomizer::GetRawRand( void )
{
    // advance pseudo random numbers
    z_ = ( 36969 * ( z_ & 0xffff ) + ( z_ >> 16 ) ) & 0xffffffff;
    w_ = ( 18000 * ( w_ & 0xffff ) + ( w_ >> 16 ) ) & 0xffffffff;

    return ( (z_ << 16) + w_ ) & 0xffffffff;

    /*
        unsigned int r = 0;

        // read random value from recording
        if ( !tRecorder::PlaybackStrict( recordingSection, r ) )
        {
            // not found. generate random value
            r = rand();

            // store it
            tRecorder::Record( recordingSection, r );
        }

        return r;
        */
}

---