class FlxUIBar

This function will be called when value will hit it's minimum

The direction from which the health bar will fill-up. Default is from left to right. Change takes effect immediately.

This function will be called when value will hit it's maximum

If false, the bar is tracking its parent (the position is synchronized with the parent's position).

BarFrames which will be used for filled bar rendering. It is recommended to use this property in tile render mode (although it will work in blit render mode also).

If this FlxBar should be killed when its empty

The maximum value the bar can be (can never be <= min)

The minimum value the bar can be (can never be >= max)

Number of frames FlxBar will have. Default value is 100. The bigger value you set then visual will change smoother.

Object to track value from

Property of parent object to track.

What 1% of the bar is equal to in terms of value (range / 100)

The percentage of how full the bar is (a value between 0 and 100)

The positionOffset controls how far offset the FlxBar is from the parent sprite (if at all)

How many pixels = 1% of the bar (barWidth (or barHeight) / 100)

How wide is the range of this bar? (max - min)

The current value - must always be between min and max

Set alpha to a number between 0 and 1 to change the opacity of the sprite.

See also:

• https://snippets.haxeflixel.com/sprites/alpha/

Class that handles adding and playing animations on this sprite.

See also:

• https://snippets.haxeflixel.com/sprites/animation/

Controls whether the object is smoothed when rotated, affects performance.

The minimum angle (out of 360°) for which a new baked rotation exists. Example: 90 means there are 4 baked rotations in the spritesheet. 0 if this sprite does not have any baked rotations.

See also:

• https://snippets.haxeflixel.com/sprites/baked-rotations/

Blending modes, just like Photoshop or whatever, e.g. "multiply", "screen", etc.

Clipping rectangle for this sprite. Changing the rect's properties directly doesn't have any effect, reassign the property to update it (sprite.clipRect = sprite.clipRect;). Set to null to discard graphic frame clipping.

Tints the whole sprite to a color (0xRRGGBB format) - similar to OpenGL vertex colors. You can use 0xAARRGGBB colors, but the alpha value will simply be ignored. To change the opacity use alpha.

See also:

• https://snippets.haxeflixel.com/sprites/color/

Set this flag to true to force the sprite to update during the draw() call. NOTE: Rarely if ever necessary, most sprite operations will flip this flag automatically.

Can be set to LEFT, RIGHT, UP, and DOWN to take advantage of flipped sprites and/or just track player orientation more easily.

See also:

• https://snippets.haxeflixel.com/sprites/facing/

Whether this sprite is flipped on the X axis.

Whether this sprite is flipped on the Y axis.

Link to current FlxFrame from loaded atlas

The height of the actual graphic or image being displayed (not necessarily the game object/bounding box).

The current display state of the sprite including current animation frame, tint, flip etc... may be null unless useFramePixels is true.

The width of the actual graphic or image being displayed (not necessarily the game object/bounding box).

Rendering variables.

The total number of frames in this image. WARNING: assumes each row in the sprite sheet is full!

The position of the sprite's graphic relative to its hitbox. For example, offset.x = 10; will show the graphic 10 pixels left of the hitbox. Likely needs to be adjusted after changing a sprite's width, height or scale.

WARNING: The origin of the sprite will default to its center. If you change this, the visuals and the collisions will likely be pretty out-of-sync if you do any rotation.

This sprite's graphic / BitmapData object. Automatically adjusts graphic size and render helpers if changed.

Change the size of your sprite's graphic. NOTE: The hitbox is not automatically adjusted, use updateHitbox() for that. WARNING: With FlxG.renderBlit, scaling sprites decreases rendering performance by a factor of about x10!

See also:

• https://snippets.haxeflixel.com/sprites/scale/

GLSL shader for this sprite. Avoid changing it frequently as this is a costly operation.

Whether or not to use a ColorTransform set via setColorTransform().

Always true on FlxG.renderBlit. On FlxG.renderTile it determines whether framePixels is used and defaults to false for performance reasons.

How fast the speed of this object is changing (in pixels per second). Useful for smooth movement and gravity.

Bit field of flags (use with UP, DOWN, LEFT, RIGHT, etc) indicating collision directions. Use bitwise operators to check the values stored here. Useful for things like one-way platforms (e.g. allowCollisions = UP;). The accessor "solid" just flips this variable between NONE and ANY.

Set the angle (in degrees) of a sprite to rotate it. WARNING: rotating sprites decreases their rendering performance by a factor of ~10x when using blitting!

How fast the spin speed should change (in degrees per second).

Like drag but for spinning.

This is how fast you want this sprite to spin (in degrees per second).

Whether this sprite is dragged along with the horizontal movement of objects it collides with (makes sense for horizontally-moving platforms in platformers for example). Use values IMMOVABLE, ALWAYS, HEAVIER or NEVER

Whether this sprite is dragged along with the vertical movement of objects it collides with (for sticking to vertically-moving platforms in platformers for example). Use values IMMOVABLE, ALWAYS, HEAVIER or NEVER

DEPRECATED Whether this sprite is dragged along with the horizontal movement of objects it collides with (makes sense for horizontally-moving platforms in platformers for example).

Apart from having a weird typo, this has been deprecated for collisionXDrag, which allows more options.

Overriding this will force a specific color to be used for debug rect (ignoring any of the other debug bounding box colors specified).

Color used for the debug rect if allowCollisions == NONE.

Color used for the debug rect if this object collides partially (immovable in the case of FlxObject, or allowCollisions not equal to ANY or NONE in the case of tiles in FlxTilemap).

Color used for the debug rect if allowCollisions == ANY.

This isn't drag exactly, more like deceleration that is only applied when acceleration is not affecting the sprite.

The bounciness of this object. Only affects collisions. Default value is 0, or "not bouncy at all."

Handy for storing health percentage or armor points or whatever.

The height of this object's hitbox. For sprites, use offset to control the hitbox position.

Setting this to true will prevent the object's bounding box from appearing when FlxG.debugger.drawDebug is true.

Whether an object will move/alter position after a collision.

Important variable for collision processing. By default this value is set automatically during at the start of update().

The virtual mass of the object. Default value is 1. Currently only used with elasticity during collision resolution. Change at your own risk; effects seem crazy unpredictable so far!

Use in conjunction with angularAcceleration for fluid spin speed control.

If you are using acceleration, you can use maxVelocity with it to cap the speed automatically (very useful!).

Set this to false if you want to skip the automatic motion/movement stuff (see updateMotion()). FlxObject and FlxSprite default to true. FlxText, FlxTileblock and FlxTilemap default to false.

The path this object follows. Not initialized by default. Assign a new FlxPath() object and start() it if you want to this object to follow a path. Set path to null again to stop following the path. See flixel.util.FlxPath for more info and usage examples.

Whether or not the position of this object should be rounded before any draw() or collision checking.

Whether or not the coordinates should be rounded during rendering. Does not affect copyPixels(), which can only render on whole pixels. Defaults to the camera's global pixelPerfectRender value, but overrides that value if not equal to null.

Controls how much this object is affected by camera scrolling. 0 = no movement (e.g. a background layer), 1 = same movement speed as the foreground. Default value is (1,1), except for UI elements like FlxButton where it's (0,0).

Whether the object collides or not. For more control over what directions the object will collide from, use collision constants (like LEFT, FLOOR, etc) to set the value of allowCollisions directly.

Bit field of flags (use with UP, DOWN, LEFT, RIGHT, etc) indicating surface contacts. Use bitwise operators to check the values stored here, or use isTouching(), justTouched(), etc. You can even use them broadly as boolean values if you're feeling saucy!

The basic speed of this object (in pixels per second).

Bit field of flags (use with UP, DOWN, LEFT, RIGHT, etc) indicating surface contacts from the previous game loop step. Use bitwise operators to check the values stored here, or use isTouching(), justTouched(), etc. You can even use them broadly as boolean values if you're feeling saucy!

The width of this object's hitbox. For sprites, use offset to control the hitbox position.

X position of the upper left corner of this object in world space.

Y position of the upper left corner of this object in world space.

A unique ID starting from 0 and increasing by 1 for each subsequent FlxBasic that is created.

Controls whether update() is automatically called by FlxState/FlxGroup.

Useful state for many game objects - "dead" (!alive) vs alive. kill() and revive() both flip this switch (along with exists, but you can override that).

Gets or sets the first camera of this object.

This determines on which FlxCameras this object will be drawn. If it is null / has not been set, it uses the list of default draw targets, which is controlled via FlxG.camera.setDefaultDrawTarget as well as the DefaultDrawTarget argument of FlxG.camera.add.

The parent containing this basic, typically if you check this recursively you should reach the state

Controls whether update() and draw() are automatically called by FlxState/FlxGroup.

Controls whether draw() is automatically called by FlxState/FlxGroup.

Creates a solid-colour filled background for health bar in the given colour, with optional 1px thick border.

Parameters:

Returns:

Creates a solid-colour filled foreground for health bar in the given colour, with optional 1px thick border.

Parameters:

Returns:

Creates a solid-colour filled health bar in the given colours, with optional 1px thick border. All colour values are in 0xAARRGGBB format, so if you want a slightly transparent health bar give it lower AA values.

Parameters:

Returns:

Creates a gradient filled health bar using the given colour ranges, with optional 1px thick border. All colour values are in 0xAARRGGBB format, so if you want a slightly transparent health bar give it lower AA values.

Parameters:

Returns:

Creates a gradient filled background for health bar using the given colour range, with optional 1px thick border.

Parameters:

Returns:

Creates a gradient filled foreground for health bar using the given colour range, with optional 1px thick border.

Parameters:

Returns:

Creates a health bar filled using the given bitmap images. You can provide "empty" (background) and "fill" (foreground) images. either one or both images (empty / fill), and use the optional empty/fill colour values All colour values are in 0xAARRGGBB format, so if you want a slightly transparent health bar give it lower AA values. NOTE: This method doesn't check if the empty image doesn't have the same size as fill image.

Parameters:

Returns:

Loads given bitmap image for health bar background.

Parameters:

Returns:

Loads given bitmap image for health bar foreground.

Parameters:

Returns:

Sets callbacks which will be triggered when the value of this FlxBar reaches min or max. Functions will only be called once and not again until the value changes. Optionally the FlxBar can be killed if it reaches min, but if will fire the empty callback first (if set)

Parameters:

Sets a parent for this FlxBar. Instantly replaces any previously set parent and refreshes the bar.

Parameters:

Set the minimum and maximum allowed values for the FlxBar

Parameters:

Tells the health bar to stop following the parent sprite. The given posX and posY values are where it will remain on-screen.

Parameters:

Track the parent FlxSprites x/y coordinates. For example if you wanted your sprite to have a floating health-bar above their head. If your health bar is 10px tall and you wanted it to appear above your sprite, then set offsetY to be -10 If you wanted it to appear below your sprite, and your sprite was 32px tall, then set offsetY to be 32. Same applies to offsetX.

Parameters:

See also:

• stopTrackingParent

Updates health bar view according its current value. Called when the health bar detects a change in the health of the parent.

Stamps health bar background on its pixels

Stamps health bar foreground on its pixels

Helper function that adjusts the offset automatically to center the bounding box within the graphic.

Parameters:

Sets the sprite's origin to its center - useful after adjusting scale to make sure rotations work as expected.

Request (or force) that the sprite update the frame before rendering. Useful if you are doing procedural generation or other weirdness!

Parameters:

Retrieve the midpoint of this sprite's graphic in world coordinates.

Parameters:

Returns:

Determines which of this sprite's pixels are at the specified world coordinate, if any. Factors in scale, angle, offset, origin, and scrollFactor.

Parameters:

Returns:

Determines which of this sprite's pixels are at the specified screen coordinate, if any. Factors in scale, angle, offset, origin, and scrollFactor.

Parameters:

Returns:

Calculates the smallest globally aligned bounding box that encompasses this sprite's width and height, at its current rotation. Note, if called on a FlxSprite, the origin is used, but scale and offset are ignored. Use getScreenBounds to use these properties.

Parameters:

Returns:

Calculates the smallest globally aligned bounding box that encompasses this sprite's graphic as it would be displayed. Honors scrollFactor, rotation, scale, offset and origin.

Parameters:

Returns:

Called whenever a new graphic is loaded for this sprite (after loadGraphic(), makeGraphic() etc).

Check and see if this object is currently on screen. Differs from FlxObject's implementation in that it takes the actual graphic into account, not just the hitbox or bounding box or whatever.

Parameters:

Returns:

Returns the result of isSimpleRenderBlit() if FlxG.renderBlit is true, or false if FlxG.renderTile is true.

Determines the function used for rendering in blitting: copyPixels() for simple sprites, draw() for complex ones. Sprites are considered simple when they have an angle of 0, a scale of 1, don't use blend and pixelPerfectRender is true.

Parameters:

Load an image from an embedded graphic file.

HaxeFlixel's graphic caching system keeps track of loaded image data. When you load an identical copy of a previously used image, by default HaxeFlixel copies the previous reference onto the pixels field instead of creating another copy of the image data, to save memory.

NOTE: This method updates hitbox size and frame size.

Parameters:

Returns:

Load graphic from another FlxSprite and copy its tile sheet data. This method can useful for non-flash targets.

Parameters:

Returns:

Helper method which allows using FlxFrame as graphic source for sprite's loadRotatedGraphic() method.

Parameters:

Returns:

Create a pre-rotated sprite sheet from a simple sprite. This can make a huge difference in graphical performance on blitting targets!

Parameters:

Returns:

This function creates a flat colored rectangular image dynamically.

HaxeFlixel's graphic caching system keeps track of loaded image data. When you make an identical copy of a previously used image, by default HaxeFlixel copies the previous reference onto the pixels field instead of creating another copy of the image data, to save memory.

NOTE: This method updates hitbox size and frame size.

Parameters:

Returns:

Checks to see if a point in 2D world space overlaps this FlxSprite object's current displayed pixels. This check is ALWAYS made in screen space, and factors in scale, angle, offset, origin, and scrollFactor.

Parameters:

Returns:

Replaces all pixels with specified Color with NewColor pixels. WARNING: very expensive (especially on big graphics) as it iterates over every single pixel.

Parameters:

Returns:

Helper method just for convenience, so you don't need to type sprite.frame = sprite.frame; You may need this method in tile render mode, when you want sprite to use its original graphic, not the graphic generated from its framePixels.

Resets frame size to frame dimensions.

Resets some internal variables used for frame BitmapData calculation.

Resets sprite's size back to frame size.

Sets the sprite's color transformation with control over color offsets. With FlxG.renderTile, offsets are only supported on OpenFL Next version 3.6.0 or higher.

Parameters:

Set how a sprite flips when facing in a particular direction.

Parameters:

Sets frames and allows you to save animations in sprite's animation controller

Parameters:

Returns:

Helper function to set the graphic's dimensions by using scale, allowing you to keep the current aspect ratio should one of the numbers be <= 0. It might make sense to call updateHitbox() afterwards!

Parameters:

Stamps / draws another FlxSprite onto this FlxSprite. This function is NOT intended to replace draw()!

Parameters:

Converts the point from screen coordinates to this sprite's pixel coordinates where (0,0) is the top left of the graphic. Factors in scale, angle, offset, origin, and scrollFactor.

Parameters:

Converts the point from world coordinates to this sprite's pixel coordinates where (0,0) is the top left of the graphic. Factors in scale, angle, offset, origin, and scrollFactor.

Parameters:

Converts the point from world coordinates to this sprite's pixel coordinates where (0,0) is the top left of the graphic. Same as worldToPixels but never uses a camera, therefore scrollFactor is ignored

Parameters:

Retrieves the BitmapData of the current FlxFrame. Updates framePixels.

Updates the sprite's hitbox (width, height, offset) according to the current scale. Also calls centerOrigin().

Override this function to draw custom "debug mode" graphics to the specified camera while the debugger's drawDebug mode is toggled on.

Parameters:

Retrieve the midpoint of this object in world coordinates.

Parameters:

Returns:

Returns the world position of this object.

Parameters:

Returns:

Returns the screen position of this object.

Parameters:

Returns:

Reduces the health variable of this object by the amount specified in Damage. Calls kill() if health drops to or below zero.

Parameters:

Check and see if this object is currently within the world bounds - useful for killing objects that get too far away.

Returns:

Check if object is rendered pixel perfect on a specific camera.

Handy function for checking if this object is touching a particular surface. Note: These flags are set from FlxG.collide calls, and get reset in super.update().

Parameters:

Returns:

Handy function for checking if this object is just landed on a particular surface. Note: These flags are set from FlxG.collide calls, and get reset in super.update().

Parameters:

Returns:

Checks to see if some FlxObject overlaps this FlxObject or FlxGroup. If the group has a LOT of things in it, it might be faster to use FlxG.overlap(). WARNING: Currently tilemaps do NOT support screen space overlap checks!

Parameters:

Returns:

Checks to see if this FlxObject were located at the given position, would it overlap the FlxObject or FlxGroup? This is distinct from overlapsPoint(), which just checks that point, rather than taking the object's size into account. WARNING: Currently tilemaps do NOT support screen space overlap checks!

Parameters:

Returns:

Checks to see if a point in 2D world space overlaps this FlxObject.

Parameters:

Returns:

Handy function for reviving game objects. Resets their existence flags and position.

Parameters:

Centers this FlxObject on the screen, either by the x axis, y axis, or both.

Parameters:

Returns:

Helper function to set the coordinates of this object. Handy since it only requires one line of code.

Parameters:

Shortcut for setting both width and Height.

Parameters:

The cameras that will draw this. Use this.cameras to set specific cameras for this object, otherwise the container's cameras are used, or the container's container and so on. If there is no container, say, if this is inside FlxGroups rather than a FlxContainer then the default draw cameras are returned.

Handy function for "killing" game objects. Use reset() to revive them. Default behavior is to flag them as nonexistent AND dead. However, if you want the "corpse" to remain in the game, like to animate an effect or whatever, you should override this, setting only alive to false, and leaving exists true.

Handy function for bringing game objects "back to life". Just sets alive and exists back to true. In practice, this function is most often called by FlxObject#reset().