src/tools/tRandom.cpp

Go to the documentation of this file.
00001 /*
00002 
00003 *************************************************************************
00004 
00005 ArmageTron -- Just another Tron Lightcycle Game in 3D.
00006 Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)
00007 
00008 **************************************************************************
00009 
00010 This program is free software; you can redistribute it and/or
00011 modify it under the terms of the GNU General Public License
00012 as published by the Free Software Foundation; either version 2
00013 of the License, or (at your option) any later version.
00014 
00015 This program is distributed in the hope that it will be useful,
00016 but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018 GNU General Public License for more details.
00019 
00020 You should have received a copy of the GNU General Public License
00021 along with this program; if not, write to the Free Software
00022 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00023   
00024 ***************************************************************************
00025 
00026 */
00027 
00028 // declaration
00029 #ifndef         TRANDOM_H_INCLUDED
00030 #include        "tRandom.h"
00031 #endif
00032 
00033 #ifdef      HAVE_STDLIB
00034 #include    <stdlib.h>
00035 #endif
00036 
00037 #include    "tError.h"
00038 #include    "tRecorder.h"
00039 #include    <cstdlib>
00040 
00041 #undef  INLINE_DEF
00042 #define INLINE_DEF
00043 
00044 // *******************************************************************************************
00045 // *
00046 // *    tRandomizer
00047 // *
00048 // *******************************************************************************************
00051 // *******************************************************************************************
00052 
00053 tRandomizer::tRandomizer( void )
00054         :randMax_( RAND_MAX )
00055 {
00056 }
00057 
00058 // *******************************************************************************************
00059 // *
00060 // *    Get
00061 // *
00062 // *******************************************************************************************
00066 // *******************************************************************************************
00067 
00068 REAL tRandomizer::Get( void )
00069 {
00070     // Grr. VisualC 6 can't handle this in one line.
00071     REAL a = GetRawRand();
00072     REAL b = randMax_;
00073 
00074     return a / b;
00075 }
00076 
00077 // *******************************************************************************************
00078 // *
00079 // *    Get
00080 // *
00081 // *******************************************************************************************
00086 // *******************************************************************************************
00087 
00088 int tRandomizer::Get( int max )
00089 {
00090     int ret = int( floorf( Get() * max ) );
00091     tASSERT( 0 <= ret );
00092     tASSERT( ret < max );
00093 
00094     return ret;
00095 }
00096 
00097 // *******************************************************************************************
00098 // *
00099 // *    GetInstance
00100 // *
00101 // *******************************************************************************************
00105 // *******************************************************************************************
00106 
00107 tRandomizer & tRandomizer::GetInstance( void )
00108 {
00109     static tRandomizer randomizer;
00110     return randomizer;
00111 }
00112 
00113 // *******************************************************************************************
00114 // *
00115 // *    ~tRandomizer
00116 // *
00117 // *******************************************************************************************
00120 // *******************************************************************************************
00121 
00122 tRandomizer::~tRandomizer( void )
00123 {
00124 }
00125 
00126 // *******************************************************************************************
00127 // *
00128 // *    tRandomizer
00129 // *
00130 // *******************************************************************************************
00134 // *******************************************************************************************
00135 
00136 tRandomizer::tRandomizer( tRandomizer const & other )
00137 {
00138     tASSERT( 0 ); // not implemented
00139 }
00140 
00141 // *******************************************************************************************
00142 // *
00143 // *    operator =
00144 // *
00145 // *******************************************************************************************
00150 // *******************************************************************************************
00151 
00152 tRandomizer & tRandomizer::operator =( tRandomizer const & other )
00153 {
00154     tASSERT( 0 ); // not implemented
00155 
00156     return *this;
00157 }
00158 
00159 // *******************************************************************************************
00160 // *
00161 // *    GetRawRand
00162 // *
00163 // *******************************************************************************************
00167 // *******************************************************************************************
00168 
00169 unsigned int tRandomizer::GetRawRand( void )
00170 {
00171     return rand();
00172 }
00173 
00174 static char const * recordingSection = "RANDOM";
00175 
00176 // *******************************************************************************************
00177 // *
00178 // *   tReproducibleRandomizer
00179 // *
00180 // *******************************************************************************************
00183 // *******************************************************************************************
00184 
00185 tReproducibleRandomizer::tReproducibleRandomizer( void )
00186 {
00187     // generate random seeds with standard random generator
00188     z_ = rand();
00189     w_ = rand();
00190     randMax_ = 0xffffffff;
00191 
00192     // archive seed
00193     tRecorder::PlaybackStrict( recordingSection, z_ );
00194     tRecorder::Record( recordingSection, z_ );
00195 
00196     tRecorder::PlaybackStrict( recordingSection, w_ );
00197     tRecorder::Record( recordingSection, w_ );
00198 
00199     /*
00200         // read RAND_MAX from recording or write it to recording
00201         if ( !tRecorder::PlaybackStrict( recordingSection, randMax_ ) )
00202             tRecorder::Record( recordingSection, randMax_ );
00203     */
00204 }
00205 
00206 // *******************************************************************************************
00207 // *
00208 // *    ~tReproducibleRandomizer
00209 // *
00210 // *******************************************************************************************
00213 // *******************************************************************************************
00214 
00215 tReproducibleRandomizer::~tReproducibleRandomizer( void )
00216 {
00217 }
00218 
00219 // *******************************************************************************************
00220 // *
00221 // *    GetInstance
00222 // *
00223 // *******************************************************************************************
00227 // *******************************************************************************************
00228 
00229 tReproducibleRandomizer & tReproducibleRandomizer::GetInstance( void )
00230 {
00231     static tReproducibleRandomizer randomizer;
00232     return randomizer;
00233 }
00234 
00235 // *******************************************************************************************
00236 // *
00237 // *    GetRawRand
00238 // *
00239 // *******************************************************************************************
00243 // *******************************************************************************************
00244 
00245 unsigned int tReproducibleRandomizer::GetRawRand( void )
00246 {
00247     // advance pseudo random numbers
00248     z_ = ( 36969 * ( z_ & 0xffff ) + ( z_ >> 16 ) ) & 0xffffffff;
00249     w_ = ( 18000 * ( w_ & 0xffff ) + ( w_ >> 16 ) ) & 0xffffffff;
00250 
00251     return ( (z_ << 16) + w_ ) & 0xffffffff;
00252 
00253     /*
00254         unsigned int r = 0;
00255 
00256         // read random value from recording
00257         if ( !tRecorder::PlaybackStrict( recordingSection, r ) )
00258         {
00259             // not found. generate random value
00260             r = rand();
00261 
00262             // store it
00263             tRecorder::Record( recordingSection, r );
00264         }
00265 
00266         return r;
00267         */
00268 }
00269 

Generated on Sat Mar 15 22:56:01 2008 for Armagetron Advanced by  doxygen 1.5.4