rand.cpp

Go to the documentation of this file.

/*__            ___                 ***************************************
/   \          /   \          Copyright (c) 1996-2021 Freeciv21 and Freeciv
\_   \        /  __/          contributors. This file is part of Freeciv21.
 _\   \      /  /__     Freeciv21 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 3 of the  License,
       |                              or (at your option) any later version.
     _/     /\                  You should have received  a copy of the GNU
    /o)  (o/\ \_                General Public License along with Freeciv21.
    \_____/ /                     If not, see https://www.gnu.org/licenses/.
      \____/        ********************************************************/
 
// utility
#include "log.h"
 
#include "rand.h"
#include "shared.h"
 
// Qt
#include <QRandomGenerator>
 
#define log_rand log_debug
 
/* A global random state:
 * Initialized by fc_srand(), updated by fc_rand(),
 * Can be duplicated/saved/restored via fc_rand_state()
 * and fc_rand_set_state().
 */
namespace {
Q_LOGGING_CATEGORY(random_category, "freeciv.random");
static std::mt19937 generator = std::mt19937();
bool is_init = false;
} // namespace
 
std::uint_fast32_t fc_rand_debug(std::uint_fast32_t size,
                                 const char *called_as, int line,
                                 const char *file)
{
  // uniform_int_distribution(a, b) is UB if a > b, so protect
  // against it. Also short-circuit for size == 1 which is always 0
  // anyway.
  if (size <= 1) {
    return 0;
  }
 
  std::uniform_int_distribution<std::uint_fast32_t> uniform(0, size - 1);
 
  auto random = uniform(generator);
  qCDebug(random_category, "%s(%lu) = %lu at %s:%d", called_as,
          (unsigned long) size, (unsigned long) random, file, line);
  return random;
}
 
void fc_srand(std::uint_fast32_t seed)
{
  generator.seed(seed);
  fc_rand_set_init(true);
}
 
bool fc_rand_is_init() { return is_init; }
 
void fc_rand_set_init(bool init) { is_init = init; }
 
namespace /* anonymous */ {
 
struct random_seed_seq {
  template <typename It> void generate(It begin, It end)
  {
    for (; begin != end; ++begin) {
      *begin = qgenerator();
    }
  }
 
  using result_type = decltype(QRandomGenerator64{}.generate());
 
private:
  QRandomGenerator64 qgenerator = QRandomGenerator64::securelySeeded();
};
} // anonymous namespace
 
void fc_rand_seed(std::mt19937 &gen)
{
  auto seed = random_seed_seq();
  gen.seed(seed);
}
 
std::mt19937 &fc_rand_state() { return generator; }
 
void fc_rand_set_state(const std::mt19937 &state)
{
  generator = state;
  fc_rand_set_init(true);
}
 
std::uint_fast32_t fc_randomly_debug(std::uint_fast32_t seed,
                                     std::uint_fast32_t size,
                                     const char *called_as, int line,
                                     const char *file)
{
  std::uint_fast32_t result;
 
#define LARGE_PRIME (10007)
#define SMALL_PRIME (1009)
 
  // Check for overflow and underflow
  fc_assert_ret_val(seed < MAX_UINT32 / LARGE_PRIME, 0);
  fc_assert_ret_val(size < SMALL_PRIME, 0);
  fc_assert_ret_val(size > 0, 0);
  result = ((seed * LARGE_PRIME) % SMALL_PRIME) % size;
 
  log_rand("%s(%lu,%lu) = %lu at %s:%d", called_as, (unsigned long) seed,
           (unsigned long) size, (unsigned long) result, file, line);
 
  return result;
}