flixel.math.FlxMath - HaxeFlixel API

A class containing a set of math-related functions.

Static variables

`@:value(0.0000001)staticinlineread onlyEPSILON:Float = 0.0000001`

Used to account for floating-point inaccuracies.

`@:value(1.79e+308)staticinlineread onlyMAX_VALUE_FLOAT:Float = 1.79e+308`

Maximum value of a floating point number.

`@:value(0x7FFFFFFF)staticinlineread onlyMAX_VALUE_INT:Int = 0x7FFFFFFF`

Maximum value of an integer.

`@:value(0.0000000000000001)staticinlineread onlyMIN_VALUE_FLOAT:Float = 0.0000000000000001`

Minimum value of a floating point number.

`@:value(-MAX_VALUE_INT)staticinlineread onlyMIN_VALUE_INT:Int = -MAX_VALUE_INT`

Minimum value of an integer.

`@:value(1.41421356237)staticinlineread onlySQUARE_ROOT_OF_TWO:Float = 1.41421356237`

Approximation of Math.sqrt(2).

Static methods

`staticinlineabsInt(n:Int):Int`

Returns the absolute integer value.

`staticinlinebound(Value:Float, ?Min:Float, ?Max:Float):Float`

Bound a number by a minimum and maximum. Ensures that this number is no smaller than the minimum, and no larger than the maximum. Leaving a bound null means that side is unbounded.

Parameters:

`Value`	Any number.
`Min`	Any number.
`Max`	Any number.

Returns:

The bounded value of the number.

`staticinlinedistanceBetween(SpriteA:FlxSprite, SpriteB:FlxSprite):Int`

Find the distance (in pixels, rounded) between two FlxSprites, taking their origin into account

Parameters:

`SpriteA`	The first FlxSprite
`SpriteB`	The second FlxSprite

Returns:

Distance between the sprites in pixels

`staticinlinedistanceToMouse(Sprite:FlxSprite):Int`

Find the distance (in pixels, rounded) from the object x/y and the mouse x/y

Parameters:

`Sprite`	The FlxSprite to test against

Returns:

The distance between the given sprite and the mouse coordinates

`staticinlinedistanceToPoint(Sprite:FlxSprite, Target:FlxPoint):Int`

Find the distance (in pixels, rounded) from an FlxSprite to the given FlxPoint, taking the source origin into account.

Parameters:

`Sprite`	The FlxSprite
`Target`	The FlxPoint

Returns:

Distance in pixels

`staticinlinedistanceToTouch(Sprite:FlxSprite, Touch:FlxTouch):Int`

Find the distance (in pixels, rounded) from the object x/y and the FlxPoint screen x/y

Parameters:

`Sprite`	The FlxSprite to test against
`Touch`	The FlxTouch to test against

Returns:

The distance between the given sprite and the mouse coordinates

`staticinlinedotProduct(ax:Float, ay:Float, bx:Float, by:Float):Float`

Finds the dot product value of two vectors

Parameters:

`ax`	Vector X
`ay`	Vector Y
`bx`	Vector X
`by`	Vector Y

Returns:

Result of the dot product

`@:value({ aDiff : EPSILON })staticinlineequal(aValueA:Float, aValueB:Float, aDiff:Float = EPSILON):Bool`

`staticinlinefastCos(n:Float):Float`

A faster, but less accurate version of Math.cos(). About 2-6 times faster with < 0.05% average error.

Parameters:

`n`	The angle in radians.

Returns:

An approximated cosine of n.

`staticinlinefastSin(n:Float):Float`

A faster but slightly less accurate version of Math.sin(). About 2-6 times faster with < 0.05% average error.

Parameters:

`n`	The angle in radians.

Returns:

An approximated sine of n.

`staticgetDecimals(n:Float):Int`

Returns the amount of decimals a Float has.

`staticinlineinBounds(Value:Float, Min:Null<Float>, Max:Null<Float>):Bool`

Checks if number is in defined range. A null bound means that side is unbounded.

Parameters:

`Value`	Number to check.
`Min`	Lower bound of range.
`Max`	Higher bound of range.

Returns:

Returns true if Value is in range.

`@:value({ IncludeEqual : false })staticinlineisDistanceToMouseWithin(Sprite:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool`

Check if the distance from the object x/y and the mouse x/y is within a specified number. A faster algorithm than distanceToMouse because the Math.sqrt() is avoided.

Parameters:

`Sprite`	The FlxSprite to test against
`Distance`	The distance to check
`IncludeEqual`	If set to true, the function will return true if the calculated distance is equal to the given Distance

Returns:

True if the distance between the sprites is less than the given Distance

`@:value({ IncludeEqual : false })staticinlineisDistanceToPointWithin(Sprite:FlxSprite, Target:FlxPoint, Distance:Float, IncludeEqual:Bool = false):Bool`

Check if the distance from an FlxSprite to the given FlxPoint is within a specified number. A faster algorithm than distanceToPoint because the Math.sqrt() is avoided.

Parameters:

`Sprite`	The FlxSprite
`Target`	The FlxPoint
`Distance`	The distance to check
`IncludeEqual`	If set to true, the function will return true if the calculated distance is equal to the given Distance

Returns:

True if the distance between the sprites is less than the given Distance

`@:value({ IncludeEqual : false })staticinlineisDistanceToTouchWithin(Sprite:FlxSprite, Touch:FlxTouch, Distance:Float, IncludeEqual:Bool = false):Bool`

Check if the distance from the object x/y and the FlxPoint screen x/y is within a specified number. A faster algorithm than distanceToTouch because the Math.sqrt() is avoided.

Parameters:

`Sprite`	The FlxSprite to test against
`Distance`	The distance to check
`IncludeEqual`	If set to true, the function will return true if the calculated distance is equal to the given Distance

Returns:

True if the distance between the sprites is less than the given Distance

`@:value({ IncludeEqual : false })staticinlineisDistanceWithin(SpriteA:FlxSprite, SpriteB:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool`

Check if the distance between two FlxSprites is within a specified number. A faster algorithm than distanceBetween because the Math.sqrt() is avoided.

Parameters:

`SpriteA`	The first FlxSprite
`SpriteB`	The second FlxSprite
`Distance`	The distance to check
`IncludeEqual`	If set to true, the function will return true if the calculated distance is equal to the given Distance

Returns:

True if the distance between the sprites is less than the given Distance

`staticinlineisEven(n:Float):Bool`

Returns true if the given number is even.

`staticinlineisOdd(n:Float):Bool`

Returns true if the given number is odd.

`staticinlinelerp(a:Float, b:Float, ratio:Float):Float`

Returns the linear interpolation of two numbers if ratio is between 0 and 1, and the linear extrapolation otherwise.

Examples:

lerp(a, b, 0) = a
lerp(a, b, 1) = b
lerp(5, 15, 0.5) = 10
lerp(5, 15, -1) = -5

`@:value({ min : 0 })staticmaxAdd(value:Int, amount:Int, max:Int, min:Int = 0):Int`

Adds the given amount to the value, but never lets the value go over the specified maximum or under the specified minimum.

Parameters:

`value`	The value to add the amount to
`amount`	The amount to add to the value
`max`	The maximum the value is allowed to be
`min`	The minimum the value is allowed to be

Returns:

The new value

`staticinlinemaxInt(a:Int, b:Int):Int`

Returns the bigger argument.

`staticinlineminInt(a:Int, b:Int):Int`

Returns the smaller argument.

`staticmouseInFlxRect(useWorldCoords:Bool, rect:FlxRect):Bool`

Returns true if the mouse world x/y coordinate are within the given rectangular block

Parameters:

`useWorldCoords`	If true the world x/y coordinates of the mouse will be used, otherwise screen x/y
`rect`	The FlxRect to test within. If this is null for any reason this function always returns true.

Returns:

true if mouse is within the FlxRect, otherwise false

`staticnumericComparison(a:Float, b:Float):Int`

Returns -1 if a is smaller, 1 if b is bigger and 0 if both numbers are equal.

`staticpointInCoordinates(pointX:Float, pointY:Float, rectX:Float, rectY:Float, rectWidth:Float, rectHeight:Float):Bool`

Returns true if the given x/y coordinate is within the given rectangular block

Parameters:

`pointX`	The X value to test
`pointY`	The Y value to test
`rectX`	The X value of the region to test within
`rectY`	The Y value of the region to test within
`rectWidth`	The width of the region to test within
`rectHeight`	The height of the region to test within

Returns:

true if pointX/pointY is within the region, otherwise false

`staticpointInFlxRect(pointX:Float, pointY:Float, rect:FlxRect):Bool`

Returns true if the given x/y coordinate is within the given rectangular block

Parameters:

`pointX`	The X value to test
`pointY`	The Y value to test
`rect`	The FlxRect to test within

Returns:

true if pointX/pointY is within the FlxRect, otherwise false

`staticpointInRectangle(pointX:Float, pointY:Float, rect:Rectangle):Bool`

Returns true if the given x/y coordinate is within the Rectangle

Parameters:

`pointX`	The X value to test
`pointY`	The Y value to test
`rect`	The Rectangle to test within

Returns:

true if pointX/pointY is within the Rectangle, otherwise false

`staticremapToRange(value:Float, start1:Float, stop1:Float, start2:Float, stop2:Float):Float`

Remaps a number from one range to another.

Parameters:

`value`	The incoming value to be converted
`start1`	Lower bound of the value's current range
`stop1`	Upper bound of the value's current range
`start2`	Lower bound of the value's target range
`stop2`	Upper bound of the value's target range

Returns:

The remapped value

`staticroundDecimal(Value:Float, Precision:Int):Float`

Round a decimal number to have reduced precision (less decimal numbers).

roundDecimal(1.2485, 2) = 1.25

Parameters:

`Value`	Any number.
`Precision`	Number of decimals the result should have.

Returns:

The rounded value of that number.

`staticinlinesameSign(a:Float, b:Float):Bool`

Checks if two numbers have the same sign (using FlxMath.signOf()).

`staticinlinesignOf(n:Float):Int`

Returns -1 if the number is smaller than 0 and 1 otherwise

`staticinlinesinh(n:Float):Float`

Hyperbolic sine.

`staticinlinevectorLength(dx:Float, dy:Float):Float`

Returns the length of the given vector.

`staticwrap(value:Int, min:Int, max:Int):Int`

Makes sure that value always stays between 0 and max, by wrapping the value around.

Parameters:

`value`	The value to wrap around
`min`	The minimum the value is allowed to be
`max`	The maximum the value is allowed to be

Returns:

The wrapped value

class FlxMath

package flixel.math

Static variables

@:value(0.0000001)staticinlineread onlyEPSILON:Float = 0.0000001

@:value(1.79e+308)staticinlineread onlyMAX_VALUE_FLOAT:Float = 1.79e+308

@:value(0x7FFFFFFF)staticinlineread onlyMAX_VALUE_INT:Int = 0x7FFFFFFF

@:value(0.0000000000000001)staticinlineread onlyMIN_VALUE_FLOAT:Float = 0.0000000000000001

@:value(-MAX_VALUE_INT)staticinlineread onlyMIN_VALUE_INT:Int = -MAX_VALUE_INT

@:value(1.41421356237)staticinlineread onlySQUARE_ROOT_OF_TWO:Float = 1.41421356237

Static methods

staticinlineabsInt(n:Int):Int

staticinlinebound(Value:Float, ?Min:Float, ?Max:Float):Float

staticinlinedistanceBetween(SpriteA:FlxSprite, SpriteB:FlxSprite):Int

staticinlinedistanceToMouse(Sprite:FlxSprite):Int

staticinlinedistanceToPoint(Sprite:FlxSprite, Target:FlxPoint):Int

staticinlinedistanceToTouch(Sprite:FlxSprite, Touch:FlxTouch):Int

staticinlinedotProduct(ax:Float, ay:Float, bx:Float, by:Float):Float

@:value({ aDiff : EPSILON })staticinlineequal(aValueA:Float, aValueB:Float, aDiff:Float = EPSILON):Bool

staticinlinefastCos(n:Float):Float

staticinlinefastSin(n:Float):Float

staticgetDecimals(n:Float):Int

staticinlineinBounds(Value:Float, Min:Null<Float>, Max:Null<Float>):Bool

@:value({ IncludeEqual : false })staticinlineisDistanceToMouseWithin(Sprite:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool

@:value({ IncludeEqual : false })staticinlineisDistanceToPointWithin(Sprite:FlxSprite, Target:FlxPoint, Distance:Float, IncludeEqual:Bool = false):Bool

@:value({ IncludeEqual : false })staticinlineisDistanceToTouchWithin(Sprite:FlxSprite, Touch:FlxTouch, Distance:Float, IncludeEqual:Bool = false):Bool

@:value({ IncludeEqual : false })staticinlineisDistanceWithin(SpriteA:FlxSprite, SpriteB:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool

staticinlineisEven(n:Float):Bool

staticinlineisOdd(n:Float):Bool

staticinlinelerp(a:Float, b:Float, ratio:Float):Float

@:value({ min : 0 })staticmaxAdd(value:Int, amount:Int, max:Int, min:Int = 0):Int

staticinlinemaxInt(a:Int, b:Int):Int

staticinlineminInt(a:Int, b:Int):Int

staticmouseInFlxRect(useWorldCoords:Bool, rect:FlxRect):Bool

staticnumericComparison(a:Float, b:Float):Int

staticpointInCoordinates(pointX:Float, pointY:Float, rectX:Float, rectY:Float, rectWidth:Float, rectHeight:Float):Bool

staticpointInFlxRect(pointX:Float, pointY:Float, rect:FlxRect):Bool

staticpointInRectangle(pointX:Float, pointY:Float, rect:Rectangle):Bool

staticremapToRange(value:Float, start1:Float, stop1:Float, start2:Float, stop2:Float):Float

staticroundDecimal(Value:Float, Precision:Int):Float

staticinlinesameSign(a:Float, b:Float):Bool

staticinlinesignOf(n:Float):Int

staticinlinesinh(n:Float):Float

staticinlinevectorLength(dx:Float, dy:Float):Float

staticwrap(value:Int, min:Int, max:Int):Int

`@:value(0.0000001)staticinlineread onlyEPSILON:Float = 0.0000001`

`@:value(1.79e+308)staticinlineread onlyMAX_VALUE_FLOAT:Float = 1.79e+308`

`@:value(0x7FFFFFFF)staticinlineread onlyMAX_VALUE_INT:Int = 0x7FFFFFFF`

`@:value(0.0000000000000001)staticinlineread onlyMIN_VALUE_FLOAT:Float = 0.0000000000000001`

`@:value(-MAX_VALUE_INT)staticinlineread onlyMIN_VALUE_INT:Int = -MAX_VALUE_INT`

`@:value(1.41421356237)staticinlineread onlySQUARE_ROOT_OF_TWO:Float = 1.41421356237`

`staticinlineabsInt(n:Int):Int`

`staticinlinebound(Value:Float, ?Min:Float, ?Max:Float):Float`

`staticinlinedistanceBetween(SpriteA:FlxSprite, SpriteB:FlxSprite):Int`

`staticinlinedistanceToMouse(Sprite:FlxSprite):Int`

`staticinlinedistanceToPoint(Sprite:FlxSprite, Target:FlxPoint):Int`

`staticinlinedistanceToTouch(Sprite:FlxSprite, Touch:FlxTouch):Int`

`staticinlinedotProduct(ax:Float, ay:Float, bx:Float, by:Float):Float`

`@:value({ aDiff : EPSILON })staticinlineequal(aValueA:Float, aValueB:Float, aDiff:Float = EPSILON):Bool`

`staticinlinefastCos(n:Float):Float`

`staticinlinefastSin(n:Float):Float`

`staticgetDecimals(n:Float):Int`

`staticinlineinBounds(Value:Float, Min:Null<Float>, Max:Null<Float>):Bool`

`@:value({ IncludeEqual : false })staticinlineisDistanceToMouseWithin(Sprite:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool`

`@:value({ IncludeEqual : false })staticinlineisDistanceToPointWithin(Sprite:FlxSprite, Target:FlxPoint, Distance:Float, IncludeEqual:Bool = false):Bool`

`@:value({ IncludeEqual : false })staticinlineisDistanceToTouchWithin(Sprite:FlxSprite, Touch:FlxTouch, Distance:Float, IncludeEqual:Bool = false):Bool`

`@:value({ IncludeEqual : false })staticinlineisDistanceWithin(SpriteA:FlxSprite, SpriteB:FlxSprite, Distance:Float, IncludeEqual:Bool = false):Bool`

`staticinlineisEven(n:Float):Bool`

`staticinlineisOdd(n:Float):Bool`

`staticinlinelerp(a:Float, b:Float, ratio:Float):Float`

`@:value({ min : 0 })staticmaxAdd(value:Int, amount:Int, max:Int, min:Int = 0):Int`

`staticinlinemaxInt(a:Int, b:Int):Int`

`staticinlineminInt(a:Int, b:Int):Int`

`staticmouseInFlxRect(useWorldCoords:Bool, rect:FlxRect):Bool`

`staticnumericComparison(a:Float, b:Float):Int`

`staticpointInCoordinates(pointX:Float, pointY:Float, rectX:Float, rectY:Float, rectWidth:Float, rectHeight:Float):Bool`

`staticpointInFlxRect(pointX:Float, pointY:Float, rect:FlxRect):Bool`

`staticpointInRectangle(pointX:Float, pointY:Float, rect:Rectangle):Bool`

`staticremapToRange(value:Float, start1:Float, stop1:Float, start2:Float, stop2:Float):Float`

`staticroundDecimal(Value:Float, Precision:Int):Float`

`staticinlinesameSign(a:Float, b:Float):Bool`

`staticinlinesignOf(n:Float):Int`

`staticinlinesinh(n:Float):Float`

`staticinlinevectorLength(dx:Float, dy:Float):Float`

`staticwrap(value:Int, min:Int, max:Int):Int`