Documentation for classes includes syntax, usage information, and code samples for methods, properties, and event handlers and listeners for those APIs that belong to a specific class in ActionScript. The classes are listed alphabetically. If you are not sure to which class a certain method or property belongs, you can look it up in the Index.


 ClassPackageDescription
 Accelerometer
citrus.input.controllers 
 ACitrusCamera
citrus.view Citrus's camera.
 ACitrusView
citrus.view This is an abstract class that is extended by any view managers, such as the SpriteView.
 AGameData
citrus.utils This is an (optional) abstract class to store your game's data such as lives, score, levels or even complex objects...
 AnimationSequence
citrus.view.away3dview 
 AnimationSequence
citrus.view.blittingview Animation Sequence represents a single animation sprite sheet.
 AnimationSequence
citrus.view.spriteview AnimationSequence.as wraps a flash MovieClip to manage different animations.
 AnimationSequence
citrus.view.starlingview The Animation Sequence class represents all object animations in one sprite sheet.
 APhysicsEngine
citrus.physics An abstract template used by every physics engine.
 APhysicsObject
citrus.objects An abstract template used by every physics object.
 AssetCache
citrus.utils 
 AVirtualButton
citrus.input.controllers 
 AVirtualJoystick
citrus.input.controllers 
 Away3DArt
citrus.view.away3dview 
 Away3DCamera2D
citrus.view.away3dview The Camera for the Away3DView in 2D mode.
 Away3DCitrusEngine
citrus.core.away3d Extends this class if you create an Away3D based game.
 Away3DPhysicsDebugView
citrus.view.away3dview A wrapper for Away3D to display the debug view of the different physics engine.
 Away3DState
citrus.core.away3d Away3DState class is just a wrapper for the AState class.
 Away3DView
citrus.view.away3dview Away3DView is based on Adobe Stage3D and the Away3D framework to render graphics.
 AwayPhysics
citrus.physics.awayphysics This is a simple wrapper class that allows you to add an AwayPhysics world to your game's state.
 AwayPhysicsDebugArt
citrus.physics.awayphysics This displays AwayPhysics's debug graphics.
 AwayPhysicsObject
citrus.objects You should extend this class to take advantage of AwayPhysics.
 BasicUI
citrus.ui.starling.basic 
 BasicUIElement
citrus.ui.starling.basic wraps a display object.
 BasicUIHearts
citrus.ui.starling.basic ...
 BasicUILayout
citrus.ui.starling.basic 
 BitFlag
citrus.datastructures 
 BlittingArt
citrus.view.blittingview 
 BlittingCamera
citrus.view.blittingview The Camera for the BlittingView.
 BlittingView
citrus.view.blittingview Blitting is a higher-performance alternative to using the built-in display list in Adobe Flash for drawing objects on the Stage.
 Box2D
citrus.physics.box2d This is a simple wrapper class that allows you to add a Box2D world to your game's state.
 Box2DComponent
citrus.system.components.box2d The base's physics Box2D Component.
 Box2DContactListener
citrus.physics.box2d Used to report the contact's interaction between objects.
 Box2DDebugArt
citrus.physics.box2d This displays Box2D's debug graphics.
 Box2DObjectPool
citrus.objects 
 Box2DPhysicsObject
citrus.objects You should extend this class to take advantage of Box2D.
 Box2DShapeMaker
citrus.physics.box2d This class helps to define some complex shapes using vertices.
 Box2DUtils
citrus.physics.box2d This class provides some useful Box2D functions.
 Bridge
citrus.objects.complex.box2dstarling A Bridge consists of Box2dPhysicsObjects connected with RevoluteJoints and is build between two Objects (usually platforms).
 ButtonController
citrus.input.controllers.gamepad.controls 
 Cannon
citrus.objects.platformer.box2d A cannon is an object which fires missiles.
 Cannon
citrus.objects.platformer.nape A cannon is an object which fires missiles.
 Car
citrus.objects.vehicle.nape This car class is a perfect example to show how to combine several physics objects and make a complex object with the Citrus Engine.
 CitrusEngine
citrus.core CitrusEngine is the top-most class in the library.
 CitrusEvent
citrus.events 
 CitrusEventDispatcher
citrus.events experimental event dispatcher (wip) TODO: - check consistency of bubbling/capturing - propagation stop ?
 CitrusGroup
citrus.core A CitrusGroup defines a group of objects which may be of different kind.
 CitrusObject
citrus.core CitrusObject is simple.
 CitrusObjectPool
citrus.objects Base CitrusObject PoolObject (ex: CitrusSprites)
 CitrusSound
citrus.sounds 
 CitrusSoundDebugArt
citrus.sounds flash.display.Sprite drawn onto by CitrusSoundSpace.
 CitrusSoundEvent
citrus.events 
 CitrusSoundGroup
citrus.sounds CitrusSoundGroup represents a volume group with its groupID and has mute control as well.
 CitrusSoundInstance
citrus.sounds CitrusSoundInstance this class represents an existing sound (playing, paused or stopped) it holds a reference to the CitrusSound it was created from and a sound channel.
 CitrusSoundObject
citrus.sounds sound object in a CitrusSoundSpace
 CitrusSoundSpace
citrus.sounds Experimental spatial sound system
 CitrusSprite
citrus.objects This is the primary class for creating graphical game objects.
 CitrusSpritePool
citrus.objects 
 CitrusStarlingJuggler
citrus.core.starling A Custom Starling Juggler used by CitrusEngine for pausing.
 Coin
citrus.objects.platformer.box2d Coin is basically a sensor that destroys itself when a particular class type touches it (often a Hero).
 Coin
citrus.objects.platformer.nape Coin is basically a sensor that destroys itself when a particular class type touches it.
 CollisionComponent
citrus.system.components.box2d The Box2D collision component, extends it to handle collision.
 Component
citrus.system A component is an object dedicate to a (single) task for an entity : physics, collision, inputs, view, movement...
 Console
citrus.core You can use the console to perform any type of command at your game's runtime.
 Crate
citrus.objects.platformer.box2d An object made for Continuous Collision Detection.
 Crate
citrus.objects.platformer.nape An object made for Continuous Collision Detection.
 DoublyLinkedList
citrus.datastructures A doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes.
 DoublyLinkedListNode
citrus.datastructures Each node is composed of a data and references (in other words, links) to the next and previous node in the sequence.
 Driver
citrus.objects.vehicle.nape Normally, in a car there is a driver right? This guy will prevent nuggets to fall (take a look on the physics debug view) as well as helping you to detect if your car crashed.
 DynamicObject
citrus.objects.platformer.simple An object that will be moved away from overlapping during a collision (probably your hero or something else that moves).
 Emitter
citrus.objects.common An emitter creates particles at a specified rate with specified distribution properties.
 EmitterParticle
citrus.objects.common 
 Enemy
citrus.objects.platformer.box2d This is a common example of a side-scrolling bad guy.
 Enemy
citrus.objects.platformer.nape This is a common example of a side-scrolling bad guy.
 Entity
citrus.system A game entity is compound by components.
 FluidBox
citrus.objects.complex.box2dstarling Example Object for simulating liquid using thresholdfilter.
 FreeboxGamepadMap
citrus.input.controllers.gamepad.maps This is the Freebox _gamepad controller preset It will work only in analog mode though (axes are weird when its not) http://www.lowcostmobile.com/img/operateurs/free/_gamepad_free.jpg
 GameObject
citrus.ui.inventory.core 
 Gamepad
citrus.input.controllers.gamepad 
 GamePadButtonRebinder
citrus.input.controllers.gamepad Experimental InputController that waits for a new gamepad buttons pressed to assign a new button to it.
 GamePadManager
citrus.input.controllers.gamepad 
 GamePadMap
citrus.input.controllers.gamepad.maps 
 Hero
citrus.objects.platformer.awayphysics 
 Hero
citrus.objects.platformer.box2d This is a common, simple, yet solid implementation of a side-scrolling Hero.
 Hero
citrus.objects.platformer.nape This is a common, simple, yet solid implementation of a side-scrolling Hero.
 Hero
citrus.objects.platformer.simple 
 HeroCollisionComponent
citrus.system.components.box2d.hero The Box2D Hero collision component.
 HeroMovementComponent
citrus.system.components.box2d.hero The Box2D Hero movement component.
 HeroPhysicsComponent
citrus.system.components.box2d.hero The Box2D Hero physics component add the fixture listener, change its friction, restitution...
 HeroViewComponent
citrus.system.components.box2d.hero The Box2D Hero view component.
 Hills
citrus.objects.platformer.box2d This class creates perpetual hills like the games Tiny Wings, Ski Safari...
 Hills
citrus.objects.platformer.nape This class creates perpetual hills like the games Tiny Wings, Ski Safari...
 IBox2DPhysicsObject
citrus.physics.box2d An interface used by each Box2D object.
 ICitrusArt
citrus.view 
 Icontrol
citrus.input.controllers.gamepad.controls defines control wrappers we use in Gamepad.
 IDebugView
citrus.physics Interface for all the debug views
 IGameObject
citrus.ui.inventory.core 
 INapePhysicsObject
citrus.physics.nape An interface used by each Nape object.
 Input
citrus.input A class managing input of any controllers that is an InputController.
 InputAction
citrus.input InputAction reinforces the Action object structure (and typing.) it contains static action phase constants as well as helpful comparators.
 InputComponent
citrus.system.components An input component, it will inform if the key is down, just pressed or just released.
 InputController
citrus.input InputController is the parent of all the controllers classes.
 InputPhase
citrus.input 
 InventoryManager
citrus.ui.inventory.core 
 ISpriteView
citrus.view The ISpriteView interface provides a common interface between a CitrusObject and the SpriteView view manager.
 IState
citrus.core Take a look on the 2 respective states to have some information on the functions.
 Keyboard
citrus.input.controllers The default Keyboard controller.
 LevelManager
citrus.utils The LevelManager is a complex but powerful class, you can use simple states for levels with SWC/SWF/XML.
 LifeBar
citrus.ui.starling A simple way to display a life bar.
 LoadManager
citrus.utils The load manager keeps track of the loading status of Loader objects, returning an overall value for all graphics that are being loaded.
 MathUtils
citrus.math 
 MathVector
citrus.math 
 MediatorState
citrus.core The MediatorState class is very important.
 Missile
citrus.objects.platformer.box2d A missile is an object that moves at a particular trajectory and speed, and explodes when it comes into contact with something.
 Missile
citrus.objects.platformer.nape A missile is an object that moves at a particular trajectory and speed, and explodes when it comes into contact with something.
 MissileWithExplosion
citrus.objects.platformer.nape A missile is an object that moves at a particular trajectory and speed, and explodes when it comes into contact with something.
 Mobile
citrus.utils This class provides mobile devices information.
 MovementComponent
citrus.system.components.box2d The Box2D movement component, we've to know the Box2D physics component to be able to move it.
 MovingPlatform
citrus.objects.platformer.box2d A platform that moves between two points.
 MovingPlatform
citrus.objects.platformer.nape A platform that moves between two points.
 Nape
citrus.physics.nape This is a simple wrapper class that allows you to add a Nape space to your game's state.
 NapeContactListener
citrus.physics.nape Used to determine the contact's interaction between objects.
 NapeDebugArt
citrus.physics.nape This displays Nape's debug graphics.
 NapeObjectPool
citrus.objects 
 NapePhysicsObject
citrus.objects You should extend this class to take advantage of Nape.
 NapeUtils
citrus.physics.nape This class provides some useful Nape functions.
 Nugget
citrus.objects.vehicle.nape In some games, like Snuggle Truck, you carry some objects in your car and you've to reach the end of the race with many of them.
 ObjectMaker2D
citrus.utils.objectmakers The ObjectMaker is a factory utility class for quickly and easily batch-creating a bunch of CitrusObjects.
 ObjectMaker3D
citrus.utils.objectmakers The ObjectMaker is a factory utility class for quickly and easily batch-creating a bunch of CitrusObjects.
 ObjectMakerStarling
citrus.utils.objectmakers The ObjectMaker is a factory utility class for quickly and easily batch-creating a bunch of CitrusObjects.
 OUYAGamepadMap
citrus.input.controllers.gamepad.maps 
 Path
citrus.objects.common This class defines a set of points (MathVector) that can be used with the MovingPlatform or other objects.
 PhysicsCollisionCategories
citrus.physics Physics Engine uses bits to represent collision categories.
 Platform
citrus.objects.platformer.awayphysics 
 Platform
citrus.objects.platformer.box2d A Platform is a rectangular object that is meant to be stood on.
 Platform
citrus.objects.platformer.nape A Platform is a rectangular object that is meant to be stood on.
 Platform
citrus.utils Last updated: March 27th 2015 by
 PolarPoint
citrus.math A simple class to create points with polar coordinates.
 Pool
citrus.objects.complex.box2dstarling Pool uses the BuoyancyController to simulate liquid physics.
 PoolObject
citrus.datastructures Object pooling is a data structure based on a simple observation : the ‘new’ operator is costly, memory allocation necessary for the object creation is a slow process.
 PS3GamepadMap
citrus.input.controllers.gamepad.maps 
 RevolvingPlatform
citrus.objects.platformer.box2d A platform that rotates around a specified point
 Reward
citrus.objects.platformer.box2d The Reward class is meant to pop out of a RewardBox when the player bumps it.
 RewardBox
citrus.objects.platformer.box2d The RewardBox is a special type of platform that you can "bump" to make a reward come out.
 Rope
citrus.objects.complex.box2dstarling A hanging rope where you can hang on and swing...
 ScreenTouch
citrus.input.controllers.starling ScreenTouch is a small InputController to get a starling touch into the input system : the common use case is if you want your hero to react on the touch of a screen and handle that in the hero's update loop without having to change your code, for example having ScreenTouch with "jump" for touchAction, let's you touch the touchTarget(the state by default) and make your Hero jump with no changes to Hero's code as it will respond to justDid("jump").
 Sensor
citrus.objects.platformer.awayphysics 
 Sensor
citrus.objects.platformer.box2d Sensors simply listen for when an object begins and ends contact with them.
 Sensor
citrus.objects.platformer.nape Sensors simply listen for when an object begins and ends contact with them.
 Sensor
citrus.objects.platformer.simple 
 SimpleCitrusSolver
citrus.physics.simple The CitrusSolver is a simple math-based collision-detection system built for doing simple collision detection in games where physics needs are light and physics engine are overkill (also useful for mobile).
 SimpleCollision
citrus.physics.simple 
 SoundChannelUtil
citrus.utils 
 SoundManager
citrus.sounds 
 SpriteArt
citrus.view.spriteview This is the class that all art objects use for the SpriteView state view.
 SpriteCamera
citrus.view.spriteview The Camera for the SpriteView.
 SpriteDebugArt
citrus.view.spriteview This class is created by the SpriteView if a CitrusSprite has no view mentionned.
 SpritePhysicsDebugView
citrus.view.spriteview 
 SpriteView
citrus.view.spriteview SpriteView is the first official implementation of a Citrus Engine "view".
 StarlingArt
citrus.view.starlingview This is the class that all art objects use for the StarlingView state view.
 StarlingCamera
citrus.view.starlingview The Camera for the StarlingView.
 StarlingCitrusEngine
citrus.core.starling Extends this class if you create a Starling based game.
 StarlingPhysicsDebugView
citrus.view.starlingview A wrapper for Starling to display the debug view of the different physics engine.
 StarlingSpriteDebugArt
citrus.view.starlingview This class is created by the StarlingView if a CitrusSprite has no view mentionned.
 StarlingState
citrus.core.starling StarlingState class is just a wrapper for the AState class.
 StarlingTile
citrus.view.starlingview 
 StarlingTileSystem
citrus.view.starlingview 
 StarlingView
citrus.view.starlingview StarlingView is based on Adobe Stage3D and the Starling framework to render graphics.
 State
citrus.core State class is just a wrapper for the AState class.
 StaticObject
citrus.objects.platformer.simple An object that does not move (probably your platform or wall).
 StickController
citrus.input.controllers.gamepad.controls 
 Teleporter
citrus.objects.platformer.box2d A Teleporter, moves an object to a destination.
 Teleporter
citrus.objects.platformer.nape A Teleporter, moves an object to a destination.
 TimeShifter
citrus.input.controllers Work In Progress.
 TmxLayer
citrus.utils.objectmakers.tmx 
 TmxMap
citrus.utils.objectmakers.tmx 
 TmxObject
citrus.utils.objectmakers.tmx 
 TmxObjectGroup
citrus.utils.objectmakers.tmx 
 TmxPropertySet
citrus.utils.objectmakers.tmx 
 TmxTileSet
citrus.utils.objectmakers.tmx 
 Tools
citrus.datastructures 
 Treadmill
citrus.objects.platformer.box2d A Treadmill is a MovingPlatform with some new options.
 UI
citrus.ui.starling 
 UIElement
citrus.ui.starling 
 UIGroup
citrus.ui.starling 
 UILives
citrus.ui.starling 
 UIScore
citrus.ui.starling 
 ViewComponent
citrus.system.components The view component, it manages everything to set the view.
 ViewportMode
citrus.core.starling 
 VirtualButton
citrus.input.controllers.displaylist 
 VirtualButton
citrus.input.controllers.starling 
 VirtualJoystick
citrus.input.controllers.displaylist Simple Flash Virtual Joystick
 VirtualJoystick
citrus.input.controllers.starling Starling Virtual Joystick (drawing itself using flash graphics -> bitmapData -> Starling Texture)
 Wheel
citrus.objects.vehicle.nape A wheel of the car.
 Xbox360GamepadMap
citrus.input.controllers.gamepad.maps