(39) 's Extra Blueprint Nodes for You as a Plugin, No C++ Required!

[SaxonRah]

@;195924

Dear Community,

Community member SaxonRah has gifted us with a whole new set of Randomization nodes!

Check out these pics!

&stc=1

&stc=1

**Latest Version of My Plugin Has The Additions**

https://wiki.unrealengine.com/File:VictoryPlugin.zip

C++ Code

Here is the C++ code for SaxonRah’s additions to my Victory BP Library

.h

/** Seed Rand with value passed
* @param seed - value to pass to the prng as the seed
*/
UFUNCTION(BlueprintCallable, Category = "VictoryBPLibrary|Random")
static void seedRand(int32 seed);

/** Seed Rand with current
*/
UFUNCTION(BlueprintCallable, Category = "VictoryBPLibrary|Random")
static void seedRandWithTime();

/** Seed Rand with entropy
* @param seed - value to pass to the prng as the seed
*/
UFUNCTION(BlueprintCallable, Category = "VictoryBPLibrary|Random")
static void seedRandWithEntropy();

/** Random Bool - Bernoulli distribution
* @param fBias - Bias of Bernoulli distribution
* @return uniformly distributed bool based on bias parameter
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static bool RandBool_Bernoulli(float fBias);

/** Random Integer - Zero to One Uniform distribution
* @return int32 - uniform distribution from 0 to 1
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static int32 RandInt_uniDis();

/** Random Integer - MIN to  Uniform distribution
* @param iMin - Minimum value of uniform distribution
* @param iMax - Maximum value of uniform distribution
* @return int32 - uniform distribution from iMin to iMax parameters
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static int32 RandInt_MINMAX_uniDis(int32 iMin, int32 iMax);

/** Random Double - Zero to One Uniform distribution
* @return double - uniform distribution from 0 to 1
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static float RandFloat_uniDis();

/** Random Double - Uniform distribution based on MIN to  parameters
* @param fMin - Minimum value of uniform distribution
* @param fMax - Maximum value of uniform distribution
* @return double - uniform distribution from fMin to fMax parameters
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static float RandFloat_MINMAX_uniDis(float fMin, float fMax);

/** Random Bool - Bernoulli distribution - Mersenne Twister
* @param fBias - Bias of Bernoulli distribution
* @return uniformly distributed bool based on bias parameter
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static bool RandBool_Bernoulli_MT(float fBias);

/** Random Integer - Zero to One Uniform distribution - Mersenne Twister
* @return int32 - uniform distribution from 0 to 1
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static int32 RandInt_uniDis_MT();

/** Random Integer - MIN to  Uniform distribution - Mersenne Twister
* @param iMin - Minimum value of uniform distribution
* @param iMax - Maximum value of uniform distribution
* @return int32 - uniform distribution from iMin to iMax parameters
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static int32 RandInt_MINMAX_uniDis_MT(int32 iMin, int32 iMax);

/** Random Float - Zero to One Uniform distribution -  Mersenne Twister
* @return float - uniform distribution from 0 to 1
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static float RandFloat_uniDis_MT();

/** Random Float - Uniform distribution based on MIN to  parameters - Mersenne Twister
* @param fMin - Minimum value of uniform distribution
* @param fMax - Maximum value of uniform distribution
* @return float - uniform distribution from fMin to fMax parameters
*/
UFUNCTION(BlueprintPure, Category = "VictoryBPLibrary|Random")
static float RandFloat_MINMAX_uniDis_MT(float fMin, float fMax);

.cpp

/**
* Contributed by: SaxonRah
* Better random numbers. Seeded with a random device. if the random device's entropy is 0; defaults to current for seed.
* can override with seed functions;
*/
//----------------------------------------------------------------------------------------------BeginRANDOM
std::random_device rd;        
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();


std::mt19937 rand_MT;
std::default_random_engine rand_DRE;


/** Construct a random device and set seed for engines dependent on entropy */
void UVictoryBPFunctionLibrary::constructRand()
{
    seed = std::chrono::system_clock::now().time_since_epoch().count();


    if (rd.entropy() == 0)
    {
        seedRand(seed);
    }else{
        seedRand(rd());
    }
}
/** Set seed for Rand */
void UVictoryBPFunctionLibrary::seedRand(int32 _seed)
{
    seed = _seed;
}


/** Set seed with for Rand */
void UVictoryBPFunctionLibrary::seedRandWithTime()
{
    seed = std::chrono::system_clock::now().time_since_epoch().count();
}


/** Set seed with entropy for Rand */
void UVictoryBPFunctionLibrary::seedRandWithEntropy()
{
    seedRand(rd());
}


/** Random Bool - Bernoulli distribution */
bool UVictoryBPFunctionLibrary::RandBool_Bernoulli(float fBias)
{
    std::bernoulli_distribution dis(fBias);
    return dis(rand_DRE);
}


/** Random Integer - Uniform distribution */
int32 UVictoryBPFunctionLibrary::RandInt_uniDis()
{
    std::uniform_int_distribution<int32> dis(0, 1);
    return dis(rand_DRE);
}
/** Random Integer - Uniform distribution */
int32 UVictoryBPFunctionLibrary::RandInt_MINMAX_uniDis(int32 iMin, int32 iMax)
{
    std::uniform_int_distribution<int32> dis(iMin, iMax);
    return dis(rand_DRE);
}


/** Random Float - Zero to One Uniform distribution */
float UVictoryBPFunctionLibrary::RandFloat_uniDis()
{
    std::uniform_real_distribution<float> dis(0, 1);
    return dis(rand_DRE);
}
/** Random Float - MIN to  Uniform distribution */
float UVictoryBPFunctionLibrary::RandFloat_MINMAX_uniDis(float fMin, float fMax)
{
    std::uniform_real_distribution<float> dis(fMin, fMax);
    return dis(rand_DRE);
}


/** Random Bool - Bernoulli distribution  -  Mersenne Twister */
bool UVictoryBPFunctionLibrary::RandBool_Bernoulli_MT(float fBias)
{
    std::bernoulli_distribution dis(fBias);
    return dis(rand_MT);
}


/** Random Integer - Uniform distribution  -  Mersenne Twister */
int32 UVictoryBPFunctionLibrary::RandInt_uniDis_MT()
{
    std::uniform_int_distribution<int32> dis(0, 1);
    return dis(rand_MT);
}
/** Random Integer - Uniform distribution  -  Mersenne Twister */
int32 UVictoryBPFunctionLibrary::RandInt_MINMAX_uniDis_MT(int32 iMin, int32 iMax)
{
    std::uniform_int_distribution<int32> dis(iMin, iMax);
    return dis(rand_MT);
}


/** Random Float - Zero to One Uniform distribution  -  Mersenne Twister */
float UVictoryBPFunctionLibrary::RandFloat_uniDis_MT()
{
    std::uniform_real_distribution<float> dis(0, 1);
    return dis(rand_MT);
}
/** Random Float - MIN to  Uniform distribution  -  Mersenne Twister */
float UVictoryBPFunctionLibrary::RandFloat_MINMAX_uniDis_MT(float fMin, float fMax)
{
    std::uniform_real_distribution<float> dis(fMin, fMax);
    return dis(rand_MT);
}

I know it’s not a riveting change but i notice i failed to use proper var names for the float variables. It should be better now.