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
 
static constexpr uint32_t ScaleToLimit(uint32_t value, uint32_t limit)
{
  return ((uint64_t)value * (uint64_t)limit) >> 32;
}
 
struct Randomizer {
  uint32_t state[2];
 
  uint32_t Next();
  void SetSeed(uint32_t seed);
 
  inline uint32_t Next(uint32_t limit) { return ScaleToLimit(this->Next(), limit); }
};
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
  uint32_t Random(const std::source_location location = std::source_location::current());
#else
  inline uint32_t Random([[maybe_unused]] const std::source_location location = std::source_location::current())
  {
    return _random.Next();
  }
#endif
 
inline uint32_t RandomRange(uint32_t limit, const std::source_location location = std::source_location::current())
{
  return ScaleToLimit(Random(location), limit);
}
 
inline uint32_t InteractiveRandom()
{
  return _interactive_random.Next();
}
 
inline uint32_t InteractiveRandomRange(uint32_t limit)
{
  return _interactive_random.Next(limit);
}
 
inline bool Chance16I(const uint32_t a, const uint32_t b, const uint32_t r)
{
  assert(b != 0);
  return (((uint16_t)r * b + b / 2) >> 16) < a;
}
 
inline bool Chance16(const uint32_t a, const uint32_t b, const std::source_location location = std::source_location::current())
{
  return Chance16I(a, b, Random(location));
}
 
inline bool Chance16R(const uint32_t a, const uint32_t b, uint32_t &r, const std::source_location location = std::source_location::current())
{
  r = Random(location);
  return Chance16I(a, b, r);
}
 
void RandomBytesWithFallback(std::span<uint8_t> buf);
 
#endif /* RANDOM_FUNC_HPP */