Math Functions

function vector ApproximateTrajectoryByTime(vector vPosStart, vector vPosEnd, float fTimeEnd, float accuracy, optional float AlternateZAccel) - KnowWonder trajectory function

function float CalculateHorizontalFOV(float fVerticalFOV) - If you have a vertical FOV calculated, this function will convert it back into UE2's default FOV system, being the horizontal FOV system

function float CalculateVerticalFOV(float fHorizontalFOV) - By default, UE2's FOV system uses a horizontal FOV system. This function casts a horizontal FOV value to a vertical FOV value, allowing for better viewing experiences across aspect ratios

function vector ComputeTrajectoryByAngle(vector vPosStart, vector vPosEnd, float fStartAngle, optional float AlternateZAccel) - KnowWonder trajectory function

function vector ComputeTrajectoryByTime(vector vPosStart, vector vPosEnd, float fTimeEnd, optional float AlternateZAccel) - KnowWonder trajectory function

function vector ComputeTrajectoryByVelocity(vector vPosStart, vector vPosEnd, float fStartVelocity, optional float AlternateZAccel) - KnowWonder trajectory function

function CrcInit() - (CRC32 function made by Mychaeel, permission granted) Initializes the function Crc() for use. Run this before using Crc()

function int Crc(coerce string sText) - (CRC32 function made by Mychaeel, permission granted) Runs a Cyclic Redundancy Check on sText and returns with an integer that will be impossible to convert back into text. You can use this to 100% verify whether sText has changed or not

function float EaseBetween(float t) - KnowWonder easing function

function float EaseBetweenBell(float t) - KnowWonder easing function

function float EaseBetweenParabola(float t) - KnowWonder easing function

function float EaseFrom(float t) - KnowWonder easing function

function float EaseTo(float t) - KnowWonder easing function

function float FClampScale(float f, float c1, float c2, float s1, float s2) - KnowWonder easing function

function float FancyEaseBetween(float t, optional float HowLinear) - KnowWonder easing function

function float GetDefaultJumpDistScalarValue(SHHeroPawn SHHP, optional bool bAccountForCurrentGravity) - Returns the default jump distance scalar value from the SHHeroPawn SHHP. bAccountForCurrentGravity will cause the calculation to take into account SHHP's current gravity

function float GetDefaultJumpValue(SHHeroPawn SHHP, bool bGetDoubleJumpZ, optional bool bAccountForCurrentGravity) - Returns the default jump height value from the SHHeroPawn SHHP. bGetDoubleJumpZ will cause the return value to reflect the double jump height value instead, and bAccountForCurrentGravity will cause the calculation to take into account SHHP's current gravity

function float GetGUIScale() - Essentially the same as GetHUDScale(), but for the GUI instead

function bool IsMovingForward(Actor A) - Returns true if the actor A is moving forward within an angle of 60 degrees

function vector Normal2D(vector V) - Removes the Z component of vector V, then normalizes the vector V, then returns it

function rotator RotationDiff(rotator B, rotator A) - Returns a rotator that equals the difference between the rotators B and A

function int RotationDir(int A, int B) - Returns the shortest angular distance between the angles A and B

function float VSize2D(vector V) - Removes the Z component of vector V, then gets the size of V, then returns it

function vector Vec(float X, float Y, float Z) - Makes a vector with the 3 floating point values provided and returns it. Vect() does not allow for variables to be provided, while Vec() does

function vector Vector2D(vector V) - Removes the Z component of vector V and returns it

static function int Ceiling(float fValue) - Rounds fValue to the next highest whole number and returns it

static function int cRNG(int iSeed, optional int iComplexity) - Returns a controlled random value based off of what iSeed equals. iComplexity determines how random the value outputted should be

static function int DegreeToInt(float fDegrees) - Returns an integer that is equal to an angle integer

static function float Fact(int iValue) - A simple factorial function. 12! is the biggest integer, and 34! is the biggest floating point

static function float FastInverseSqrt(float fValue, optional int iIterations) - Returns the inverse square root of fValue through a faster calculation method, although slightly less accurate version of the original square root formula. The higher the value of iIterations, the higher the accuracy, but the more computation time that will be required

static function int Floor(float fValue) - Rounds fValue to the next lowest whole number and returns it

static function float GetHUDScale(Canvas C) - Returns a scale to apply to a HUD item. This is essential for proper HUD item scaling

static function float GetMaxFloat(optional bool bGetInfinite) - Returns the maximum floating point value. bGetInfinite will cause the return value to equal an infinite value, which won't work well with strings

static function bool IsActorBehindActor(Actor A1, Actor A2, optional float fAttackAngle) - Returns true if actor A1 is behind actor A2. Whether or not the actor is behind an actor is dependent on the attack angle (since this is a common use-case), which by default is 60.0, but can be overridden by providing fAttackAngle

static function float IntToDegree(int iAngle) - Returns a float that is equal to a rotation degree

static function bool IsDivisible(float A, float B) - Returns true if A is divisible by B

static function bool IsEven(int I) - Returns true if I is an even integer

static function bool IsLeapYear(int I) - Returns true if I is equal to a leap year

static function bool IsOdd(int I) - Returns true if I is an odd integer

static function bool IsPrime(int iValue) - Returns true if iValue is a prime number

static function bool IsValueInRange(int iValue, int iMinRange, int iMaxRange) - Returns true if the value iValue is in range of the values iMinRange and iMaxRange

static function Next(out int iSeed) - Outputs the next controlled random value based off of iSeed, where iSeed will both be the random value and the next seed to use

static function bool PercentChance(float fChance) - Returns true if the percentage chance fChance rolls true

static function float Pow(float Base, int Exponent) - An alias for the operator ** that allows you to get the power of Base from Exponent, then returns it

static function int Rand32() - Returns a random 32-bit integer ranging from 0-2147483647

static function int Rand16() - Returns a random 16-bit integer ranging from 0-65535

static function Color RandColor(byte Min, byte Max, optional byte Alpha, optional bool bRandomAlpha) - Returns a randomized color between the byte ranges of Min and Max, with the alpha Alpha, and returns. If bReturnAlpha=true, then the alpha amount will be randomized between Min and Max

static function int RandRange32(int Min, int Max) - Returns a random 32-bit integer between Min and Max

static function int RandRange16(int Min, int Max) - Returns a random 16-bit integer between Min and Max

static function float RandRangeFloat(float Min, float Max) - Returns a random floating point value between Min and Max. This function has the advantage of auto-flipping Min and Max when applicable, so it's overall more helpful than RandRange()

static function int RandRangeInt(int Min, int Max) - Returns a random integer value between Min and Max. This should always be used when using integer values, as using the original RandRange() function will cause the Max value to be returned every 1/30k iterations, since RandRange() returns a float value which will be truncated to an integer

static function rotator Rota(int Pitch, int Yaw, int Roll) - Makes a rotator with the 3 integer values provided and returns it. Rot() does not allow for variables to be provided, while Rota() does

static function RotateVector(out vector A, vector B, float Degree) - Rotates the vector A toward vector B by Degree degrees and outputs it through vector A

static function float Round(float fValue, optional float Step) - Rounds fValue to the closest Step (Step's default value is 1.0) and returns it

static function array<int> ShuffleIntArray(int iLength) - Returns an array of integers that contain shuffled index values calculated with the provided array length

static function int Truncate(float fValue) - Truncates fValue to the next lowest whole number and returns it

static function int wRNG(array<int> Is) - Returns a weighted index value that corresponds with the array of weights provided in Is. This can be used for easy weighted RNG calculations