random_func.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef RANDOM_FUNC_HPP
#define RANDOM_FUNC_HPP
 
#if defined(__APPLE__)
  /* Apple already has Random declared */
# define Random OTTD_Random
#endif /* __APPLE__ */
 
struct Randomizer {
  uint32_t state[2];
 
  uint32_t Next();
  uint32_t Next(uint32_t limit);
  void SetSeed(uint32_t seed);
};
extern Randomizer _random; 
extern Randomizer _interactive_random; 
 
struct SavedRandomSeeds {
  Randomizer random;
  Randomizer interactive_random;
};
 
inline void SaveRandomSeeds(SavedRandomSeeds *storage)
{
  storage->random = _random;
  storage->interactive_random = _interactive_random;
}
 
inline void RestoreRandomSeeds(const SavedRandomSeeds &storage)
{
  _random = storage.random;
  _interactive_random = storage.interactive_random;
}
 
void SetRandomSeed(uint32_t seed);
#ifdef RANDOM_DEBUG
# ifdef __APPLE__
#   define OTTD_Random() DoRandom(__LINE__, __FILE__)
# else
#   define Random() DoRandom(__LINE__, __FILE__)
# endif
  uint32_t DoRandom(int line, const char *file);
# define RandomRange(limit) DoRandomRange(limit, __LINE__, __FILE__)
  uint32_t DoRandomRange(uint32_t limit, int line, const char *file);
#else
  static inline uint32_t Random()
  {
    return _random.Next();
  }
 
  static inline uint32_t RandomRange(uint32_t limit)
  {
    return _random.Next(limit);
  }
#endif
 
inline uint32_t InteractiveRandom()
{
  return _interactive_random.Next();
}
 
inline uint32_t InteractiveRandomRange(uint32_t limit)
{
  return _interactive_random.Next(limit);
}
 
inline bool Chance16I(const uint a, const uint b, const uint32_t r)
{
  assert(b != 0);
  return (((uint16_t)r * b + b / 2) >> 16) < a;
}
 
#ifdef RANDOM_DEBUG
# define Chance16(a, b) Chance16I(a, b, DoRandom(__LINE__, __FILE__))
#else
inline bool Chance16(const uint a, const uint b)
{
  return Chance16I(a, b, Random());
}
#endif /* RANDOM_DEBUG */
 
#ifdef RANDOM_DEBUG
# define Chance16R(a, b, r) (r = DoRandom(__LINE__, __FILE__), Chance16I(a, b, r))
#else
inline bool Chance16R(const uint a, const uint b, uint32_t &r)
{
  r = Random();
  return Chance16I(a, b, r);
}
#endif /* RANDOM_DEBUG */
 
void RandomBytesWithFallback(std::span<uint8_t> buf);
 
#endif /* RANDOM_FUNC_HPP */