DeterministicRandom.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstdint>

 
namespace core {

[[nodiscard]] constexpr std::uint64_t splitMix64(std::uint64_t value) noexcept {
    value = (value ^ (value >> 30)) * 0xBF58476D1CE4E5B9ULL;
    value = (value ^ (value >> 27)) * 0x94D049BB133111EBULL;
    return value ^ (value >> 31);
}

[[nodiscard]] constexpr std::uint64_t deriveSeed(std::uint64_t baseSeed, std::uint64_t step,
                                                 std::uint64_t entityId) noexcept {
    std::uint64_t seed = splitMix64(baseSeed);
    seed = splitMix64(seed ^ step);
    seed = splitMix64(seed ^ entityId);
    return seed;
}

class DeterministicRandom {
public:
    explicit DeterministicRandom(std::uint64_t seed) noexcept : _state(seed) {}

    [[nodiscard]] std::uint32_t nextUInt32() noexcept {
        _state += 0x9E3779B97F4A7C15ULL;
        return static_cast<std::uint32_t>(splitMix64(_state) >> 32);
    }

    [[nodiscard]] float nextFloat01() noexcept {
        constexpr float UINT32_RANGE = 4294967296.0f;  // 2^32
        return static_cast<float>(nextUInt32()) / UINT32_RANGE;
    }

    [[nodiscard]] float nextRange(float min, float max) noexcept {
        return min + nextFloat01() * (max - min);
    }

    [[nodiscard]] int nextInt(int min, int max) noexcept {
        if (max <= min) {
            return min;
        }
        const std::uint32_t etendue = static_cast<std::uint32_t>(max - min) + 1U;
        // `2^32 mod etendue` : le nombre de valeurs en trop, celles qui n'ont pas de contrepartie
        // sur tout l'intervalle. On rejette la queue BASSE, `[0, reste[`, et non la haute.
        //
        // Rejeter la queue haute serait plus naturel à lire — « au-delà du dernier multiple
        // complet » — mais ce seuil vaut `2^32` quand `etendue` divise `2^32`, et `2^32` ne tient
        // pas dans un `std::uint32_t` : il retombe à 0, la condition devient toujours vraie, et la
        // boucle ne se termine jamais. Le défaut ne se voit que sur les **puissances de deux** :
        // un d6 et un d20 passent, un d8 bloque. C'est un test de rejouabilité sur 3d8 qui l'a
        // trouvé, pas une relecture.
        const std::uint32_t reste = (std::uint32_t{0} - etendue) % etendue;
        std::uint32_t tirage = nextUInt32();
        while (tirage < reste) {
            tirage = nextUInt32();
        }
        return min + static_cast<int>(tirage % etendue);
    }
 
private:
    std::uint64_t _state;
};
 
}  // namespace core