© 2017-2019 Prismatic Realms, Inc.  All rights reserved.

Memroid

GameMaker Studio 2 Extensions

Coming Soon

PRActionEaseCubicIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Cubic In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconJoyGetTouchRadius

PRVirconSetActive(active) Set whether the PRVircon UI is active (accepts user interaction) or not. Parameters: activetrue or false indicating whether the PRVircon UI should accept user interaction or not. Return Value: n/a

PRActionQFlipXY

PRVirconJoySetTouchRadius(joyId, touchRadius) Sets the given joystick's touch radius size in pixels.  A larger touch radius means that there is more area for the player's fingers/touches to be detected.  Please note that the touch radius size is uniformly affacted by the joystick's scale setting, so set the touch radius as though the joystick scale was set to 1. Parameters:joyId The joystick ID. touchRadius The touch radius size in pixels. Return Value: n/a

PRVirconBtnSetVisible(btnId, visible) Sets whether or not the given button should be visible.  When not visible, the button will receive no input from the player. Parameters:btnId The button ID. visible true if button should be visible.  false if hidden. Return Value: n/a

PRActionEaseCircularOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Circular Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconJoySetRotation

PRActionQBreathe

PRVirconJoyGetId(name) Returns the id of the joystick with the given name. Parameters:name The name of the joystick. Return Value: The id of the joystick.

PRVirconJoySetScale

PRVirconJoyGetScale(joyId) Returns the scale value of the given joystick's sprites. Parameters:joyId The joystick ID. Return Value: The scale value of the joystick's sprites.

BUY NOW

PRVirconJoySetTravelDistance

PRActionEaseCircularInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Circular In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconGetActive() Returns true or false indicating if the PRVircon UI is active (accepts user interaction) or not. Parameters: n/a Return Value: true or false indicating if the PRVircon UI is active (accepts user interaction.)

PRVirconJoyIsUpRight

PRVirconJoySetSnapsToCenter(joyId, snapsToCenter) Sets the given joystick's snap-to-center behaviour.  When set to true, the joystick will automatically jump back to its centre when the player lets go of it.  If false, the joystick stays in place when it's let go of. Parameters:joyId The joystick ID. snapsToCenter true or false, indicating if the joystick should snap to center or not. Return Value: n/a

PRVirconBtnGetVisible(btnId) Returns true or false indicating if the given button is set to be visible or not. Parameters:btnId The button ID. Return Value: true or false.

PRActionQBounce

PRVirconJoyGetDeadzone(joyId) Returns the given joystick's deadline size in pixels. Parameters:joyId The joystick ID. Return Value: The deadzone size in pixels.

PRVirconJoyGetRotation

PRActionEaseCircularIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Circular In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionQBlendFlash

PRVirconJoySetBlend

PRVirconJoyGetRotation(joyId) Returns the rotation value of the given joystick's sprites. Parameters:joyId The joystick ID. Return Value: The rotation value of the joystick's sprites.

PRVirconJoyGetTravelDistance

PRVirconJoyIsRight

PRVirconJoySetDeadzone(joyId, deadzone) Sets the given joystick's deadzone size in pixels.  Please note that the deadzone size is uniformly affacted by the joystick's scale setting, so set the deadzone size as though the joystick scale was set to 1. Parameters:joyId The joystick ID. deadzone The deadzone size in pixels. Return Value: n/a

PRActionEaseBackOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Back Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 A multiplier that increases or decreases the effect of the Back In motion.  Setting this to 1 will use the default effect.  Setting it to 2 will double the effect while setting it to 0.5 will half the effect. Return Value: The calculated result.

PRVirconSetVisible(visible) Sets whether the PRVircon should be visible (drawn) or not. Parameters: visibletrue or false, indicating if the PRVircon UI should be drawn or not. Return Value: n/a

PRVirconJoyGetYValue

PRVirconJoyGetAxisRestrict(joyId) Returns the given joystick's axis restriction setting. Parameters:joyId The joystick ID. Return Value: PRVirconAxisVert if the joystick is restricted to the vertical axis only.  PRVirconAxisHorz if the joystick is restricted to the horizontal axis only.  Or noone for neither.

PRVirconJoySetSprite

PRActionEaseBackInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Back In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 A multiplier that increases or decreases the effect of the Back In motion.  Setting this to 1 will use the default effect.  Setting it to 2 will double the effect while setting it to 0.5 will half the effect. Return Value: The calculated result.

PRActionQAlphaFlash

Joystick Behaviour

PRVirconJoyGetLabelYOffset(joyId) Returns the y-offset of the given joystick's label sprite. Parameters:joyId The joystick ID. Return Value: The label sprites's y-offset value.

Compound Action Functions

PRVirconJoySetDeadzone

PRVirconGetVisible() Returns true or false indicating if the PRVircon UI is currently visible or not. Parameters: n/a Return Value: true or false indicating if the PRVircon UI is currently visible or not.

PRActionEaseSinusoidalOut

PRActionEaseBackIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Back In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 A multiplier that increases or decreases the effect of the Back In motion.  Setting this to 1 will use the default effect.  Setting it to 2 will double the effect while setting it to 0.5 will half the effect. Return Value: The calculated result.

PRVirconJoyIsDownRight

PRVirconJoySetAxisRestrict(joyId, axisRestrict) Sets the given joystick's axis restriction.   Parameters:joyId The joystick ID. axisRestrict Set to PRVirconAxisVert to allow the joystick to only move vertically and PRVirconAxisHorz for horizontal joystick movement only.  Set to noone to lift the restriction. Return Value: n/a

PRVirconJoyGetXValue

PRVirconJoySetSprite(joyId, nubSprite, outlineSprite) Sets the given joystick's nub and outline sprites. Parameters:joyId The joystick ID. nubSprite The sprite to use for the joystick nub. outlineSprite The sprite to use for the joystick outline.  Or noone if no outline sprite is desired. Return Value: n/a

PRVirconJoySetLabelOffset

PRActionEaseSinusoidalInOut

PRVirconBtnGetLabelYOffset

VARIABLES

PRVirconJoySetSnapsToCenter

PRVirconJoyGetLabelXOffset(joyId) Returns the x-offset of the given joystick's label sprite. Parameters:joyId The joystick ID. Return Value: The label sprites's x-offset value.

PRVirconJoyGetDeadzone

PRVirconSetAlpha(alpha) Sets the current alpha that the PRVircon UI will use when drawing itself. Parameters: alphaThe alpha value that the PRVircon UI will use to draw itself. Return Value: n/a

PRVirconJoyIsDown

PRVirconJoyGetYInvert(joyId) Returns whether or not the given joystick inverts it's vertical axis values. Parameters:joyId The joystick ID. Return Value: true or false

Button Appearance

PRVirconJoySetScale(joyId, scale) Sets the sizing scale for the given joystick's nub and outline sprites when drawn, with 1 being normal size. Parameters:joyId The joystick ID. scale The scale size. Return Value: n/a

PRVirconJoyGetLabelYOffset

PRVirconBtnGetLabelXOffset

PRVirconJoyGetSnapsToCenter

Getting Started To use PRVircon in your GameMaker Studio 2 projects, import all of the extension groups and objects that don’t begin with "Test". Then, drag the persistent oPRVirconController object into your project's first room.  (You are free to rename this object if you wish.)  The location of the object within the room doesn't matter. By default, the GUI size used for the PRVircon UI will be set to the current GUI size.  If you prefer that PRVircon use a different GUI size, then change the parameters of the call to _PRVirconInit (found in the oPRVirconController object's Create event) as desired. Then, either in the oPRVirconController object's Create event, or elsewhere, build your awesome Vircon UI using the included extension functions PRVirconJoyAdd and PRVirconBtnAdd.  Finally, customize their look and behaviour using functions such as PRVirconBtnSetLabel, PRVirconJoySetDeadzone and many others! That’s it!

PRVirconJoyAdd(name, nubSprite, outlineSprite, hAlign, vAlign, xOffsetPos, yOffsetPos, scale, rotation) Adds a new virtual joystick to the PRVircon UI. Parameters: name The name to assign to the new joystick.  Useful for tracking it in the GMS debugger and can be used to lookup the joystick's ID. nubSprite The sprite image to use for the joystick's nub. outlineSprite The sprite image to use for the joystick's bounds outline. hAlign Set to PRVirconHAlignLeft, PRVirconHAlignCenter or PRVirconHAlignRight.  Determines if the joystick's X offset should be relative to the left, center or right side of the GUI display. vAlign Set to PRVirconVAlignTop, PRVirconVAlignMiddle or PRVirconVAlignBottom.  Determines if the joystick's Y offset should be relative to the top, middle or bottom of the GUI display. xOffsetPos The x position of the joystick, relative to either the left, center or right of the GUI display, depending on the value given in hAlign. yOffsetPos The y position of the joystick, relative to either the top, middle or bottom of the GUI display, depending on the value given in vAlign. scale How much to scale the joystick sprites, with 1 being no scaling.  Larger values will increase the size of the sprites while values lower than 1 will decrease the size of the sprites. rotation The angle at which to rotate the joystick sprites in degrees. Return Value: The new virtual joystick's ID.

PRVirconBtnGetName

PRVirconJoyGetName

PRVirconGetAlpha() Returns the current PRVircon alpha draw setting. Parameters: n/a Return Value: The alpha value that the PRVircon uses the draw itself.

PRVirconJoyIsDownLeft

PRVirconBtnSetRotation

PRVirconJoySetRotation(joyId, rotation) Sets the rotation angle for the given joystick's nub and outline sprites when drawn. Parameters:joyId The joystick ID. rotation The rotation angle. Return Value: n/a

PRVirconJoyGetLabelXOffset

PRVirconBtnAdd

PRVirconGetGUIHeight() Returns the height of the GUI that the PRVircon UI will draw itself in. Parameters:n/a Return Value: The GUI height.

PRVirconJoySetAxisRestrict

PRVirconBtnGetId

PRVirconJoyGetId

PRVirconHAlignCenter Specifies a center alignment along the horizontal. PRVirconHAlignLeft Specifies a left alignment along the horizontal. PRVirconHAlignRight Specifies a right alignment along the horizontal. PRVirconVAlignBottom Specifies a bottom alignment along the vertical. PRVirconVAlignMiddle Specifies a middle alignment along the vertical. PRVirconVAlignTop Specifies a top alignment along the vertical.

PRVirconClear() Removes all PRVircon UI elements (joysticks, buttons, etc.) Parameters: n/a Return Value: n/a

PRVirconBtnIsDown(btnId) Returns true if the button is currently being pressed down. Parameters:btnId The button ID. Return Value: true or false

PRVirconJoyIsLeft

PRVirconBtnSetScale

PRVirconJoySetNotches

Button Behaviour

PRVirconGetGUIWidth() Returns the width of the GUI that the PRVircon UI will draw itself in. Parameters:n/a Return Value: The GUI width.

PRVirconJoyGetAxisRestrict

PRVirconBtnSetScript

PRVirconJoySetYInvert

PRActionEaseSinusoidalIn

PRVirconAxisHorz Specifies only the horizontal joystick axis. PRVirconAxisVertSpecifies only the vertical joystick axis.

PRVirconJoyIsUpLeft

PRVirconBtnSetScript(btnId, script) Assigns a script to the given button.  The script will be called once each time the button is pressed and once each time it is released.  In the case of a toggle button, "releasing" means returning the button to its unpressed state. The script assigned should receive two arguments, the first of which will receive the button's ID.  The second script parameter will contain either true when the button is pressed and false when the button is released. Parameters:btnId The button ID. scriptThe script to assign to the button.  Or noone is no script should be assigned. Return Value: n/a

PRVirconBtnGetId(name) Returns the id of the button with the given name. Parameters:name The name of the button. Return Value: The id of the button.

PRVirconBtnSetLabelOffset

PRActionEaseQuinticOut

PRVirconBtnSetTouchRadius

PRVirconJoySetTouchRadius

PRVirconBtnGetScript

PRVirconJoyGetYInvert

PRActionEaseQuinticInOut

PRVirconBtnGetScript(btnId) Returns the script assigned to the button that is executed when the button is pressed and released.  Returns noone if no script assigned. Parameters:btnId The button ID. Return Value: The script assigned to the button, or noone if none.

PRVirconJoyIsUp

PRVirconGetAlpha

Instance Variables PRAction exposes no public instance variables.

Adding Buttons

PRVirconBtnSetLabel

PRVirconBtnSetScale(btnId, scale) Sets the sizing scale for the given buttons' sprite when drawn, with 1 being normal size. Parameters:btnId The button ID. scale The scale size. Return Value: n/a

What is PRAction? PRAction is a GameMaker Studio 2 extension that enables you to animate anything in your GameMaker projects with ease.  Much more than a set of tweening or easing functions, PRAction is a fully-featured and easy-to-use action system. It will greatly reduce the amount of code you need to write when adding animations to your game. Use it to quickly bring life to your user interfaces, animate game logos, scroll game credits, create cut-scenes, animate your in-game objects, and perform background animations and transitions.  You can even run actions against non-graphical objects and use actions to trigger non-graphical tasks such as playing audio, calling scripts and events and lots more.  Whatever you can think of, it can be done.  To top it all off, it’s super-easy to use!  It works in both VM and YYC.  

PRVirconBtnSetToggleState

PRActionEaseQuinticIn

Button Input

Joystick Input

PRVirconBtnAdd(name, sprite, spriteSel, hAlign, vAlign, xOffsetPos, yOffsetPos, scale, scaleSel, rotation) Adds a new virtual button to the PRVircon UI. Parameters: name The name to assign to the new button.  Useful for tracking it in the GMS debugger and can be used to lookup the button's ID. sprite The sprite image to use for the button. spriteSel The sprite image to use for the button when it is pressed.  Set to noone to use the same sprite given in sprite. hAlign Set to PRVirconHAlignLeft, PRVirconHAlignCenter or PRVirconHAlignRight.  Determines if the button's X offset should be relative to the left, center or right side of the GUI display. vAlign Set to PRVirconVAlignTop, PRVirconVAlignMiddle or PRVirconVAlignBottom.  Determines if the button's Y offset should be relative to the top, middle or bottom of the GUI display. xOffsetPos The x position of the button, relative to either the left, center or right of the GUI display, depending on the value given in hAlign. yOffsetPos The y position of the button, relative to either the top, middle or bottom of the GUI display, depending on the value given in vAlign. scale How much to scale the button's sprite, with 1 being no scaling.  Larger values will increase the size of the sprite while values lower than 1 will decrease the size. scaleSel How much to scale the button's sprite when it is pressed, with 1 being no scaling.  Larger values will increase the size of the sprite while values lower than 1 will decrease the size.  Set to a smaller scale value than scale to make the button appear to animate when it's pressed. rotation The angle at which to rotate the button sprite in degrees. Return Value: The new virtual button's ID.

Getting Started

PRVirconBtnSetTouchRadius(btnId, touchRadius) Sets the given button's touch radius size in pixels.  A larger touch radius means that there is more area for the player's fingers/touches to be detected.  Please note that the touch radius size is uniformly affacted by the button's scale setting, so set the touch radius as though the button scale was set to 1. Parameters:btnId The button ID. touchRadius The touch radius size in pixels. Return Value: n/a

What is PRVircon? PRVircon is a GameMaker Studio 2 extension that enables you to add virtual joysticks and buttons to your GameMaker games with ease.  Add as many virtual joysticks and buttons as you need.  Because PRVircon completely supports multi-touch, your player(s) will be able to interact with all virtual elements simultaneously up to the maximum number of touches supports by your device. The included UI components are modular, allowing you to mix and match multiple button and joystick styles and colors to create your own unique Vircon UI.  Easily change a UI component's size, rotation, color blend and label offsets for further UI customization.  You can also easily incorporate your own UI sprites instead. Joysticks can be restricted to either the horizontal or vertical axes for games that require only up and down or left and right inputs.  You can also disable a joysticks's snap-to-center feature for joysticks that need to stay in place after the player lets go of them, useful for throttle-style sticks.  Invert the Y-axis return values so that up is down and down is up, great for flight sims. Button UI elements can work like traditional push in and release style buttons, or as push-in and push-out style toggle buttons, useful for buttons like always-on turbo.  Poll joystick and button states at any time or assign your own scripts to be executed when a button is pushed and released. Easily hide or show the Vircon UI, enable or disable user interaction and set the UI alpha level with ease.  In addition, PRVircon manages it’s own settable GUI size, which can be different from your game’s GUI size. If you need to add virtual controls to your GameMaker games, we are sure you will love this easy to use extension!  It works in both VM and YYC.

PRVirconJoyPressed

PRActionEaseQuarticOut

Adding Joysticks Add virtual joysticks to your PRVircon UI using the PRVirconJoyAdd function.  For example: leftStick = PRVirconJoyAdd("Left Stick", sPRVircon_Joy_Nub1a, sPRVircon_Joy1_ORound, PRVirconHAlignLeft, PRVirconVAlignBottom, 130, -130, 1, 0); The above statement adds a virtual joystick named "Left Stick" positioned 130 pixels from the left side of the screen and 130 pixels from the bottom of the screen, at normal scale size and with no rotation to the sprite images used.  It uses Style 1a for the joystick nub sprite and Style 1 Round for the joystick's outline sprite.  The joystick ID is captured in the variable leftStick.

PRVirconBtnSetBlend

PRVirconClear

Instance Variables The following is a list of instance variables defined in the PRState extension. PRStateData1 PRStateData2 PRStateData3 These variables are (optionally) set when calling the PRStateSet function, but you can modify the contents of these variables at any time by directly assigning values to them.  They can contain completely arbitrary data and you can use them in whatever manner you wish when handling your object states.

Reading Input

PRActionInit() Initializes the current object as a PRAction object.  Call this once in your object's Create event before calling any other PRAction functions against the object. Parameters: n/a Return Value: n/a

PRVirconBtnGetToggleState

PRActionEaseQuarticInOut

PRVirconBtnIsReleased

PRVircon Alignments

PRVirconJoySetXYValue(joyId, newX, newY) Sets the given joystick's position to the provided newX and newY values.  If these values define a point outside of the joystick's max travel distance, that point will be clamped to the max distance that the joystick can reach along the same angle.  Please note that this function is meant to be called on a joystick that has had its Snap to Center setting set to false   For joysticks that snap to center, calling this function will affect the joystick's position for a single frame and then snap back to the center on the next frame.  Also note that if the joystick's y-invert setting is true, the given newY value will represent a point that is inverted. Parameters:joyId The joystick ID. newX The x-value to set the joystick to. newY The y-value to set the joystick to. Return Value: n/a

Contents

PRVirconBtnSetToggleState(btnId, toggle) Sets the given toggle button's state to either pressed (toggle is true) or unpressed (toggle is false.)  Has no effect if the button isn't set as a toggle button.  Does not trigger the button's script. Parameters:btnId The button ID. toggle true to set the toggle button as pressed, false to set it as unpressed. Return Value: n/a

What is PRState? PRState is a GameMaker Studio 2 extension that enables you to quickly and easily implement state machines for your game objects. Use this to group your object's Step Event (frame update) code into logical units (states) that you can easily switch between using a single command. Prevent unwanted states from running by specifying "valid from" state lists. The convenient "mode" argument passed to your script will tell you when you should run your state setup code, when to run state cleanup code and when to run your core state code. Turn on and off verbose logging so that you can watch when your objects are switching states to make sure they are running as desired. Say good-bye to huge, unwieldy Step events and hello to state-switching simplicity and code organization. It works in both VM and YYC.

PRVirconJoySetXYValue

PRActionEaseQuarticIn

Adding Buttons Coming soon.

PRVirconBtnGetScale

UI Functions

UI Control

PRVirconBtnSetIsToggle

Functions The following is a list of functions defined in PRState.  Please note that for all of the functions below that have an obj argument, you must supply an object instance that has been previously setup to use PRState.  See How To Use tab for information on how to do this. Also note that this extension defines several "internal" functions beginning with an underscore (_).  These functions are not intended for you to call from within you project and are only meant to be used by PRState itself. PRStateAdd(obj, stateName, script, optionalValidFromStates)Adds a new state to an object.Parameters:    obj: The object to add the new state to.   stateName: The name of the state to add.   script: The script that will be called to handle the state.   optionalValidFromStates: Array of state names that are valid from states (optional.)Return Value:    n/a PRStateCanSet(obj, stateName)Returns whether or not the object can be set to the given state taking into consideration the valid from states assigned to the object's current state.Parameters:    obj: The object to test.   stateName: The name of the state to test.Return Value:    true if the object is capable of switching to the given state, false otherwise. PRStateCurrent(obj) Returns the object's current state.Parameters:    obj: The object to get the current state from.Return Value:    The current state name, or noone if none. PRStateCurrentScript(obj) Returns the object's current state script. Parameters:    obj: The object to get the current state script from. Return Value:    The current state script, or noone if none. PRStateDestroy() Clears all states and state data from the current object.  Call this once in your object's Destroy event.Parameters:    n/a Return Value:    n/a PRStateInit() Initializes the current object as a PRState object.  Call this once in your object's Create event before calling any other PRState functions against the object. Parameters:    n/a Return Value:    n/a PRStatePrevious(obj) Returns the object's previous state.Parameters:    obj: The object to get the previous state from. Return Value:    The object's previous state name, or noone if none. PRStateSet(obj, stateName, optionalData1, optionalData2, optionalData3)Sets the object's current state.  Then, if it had one, the object's previous state script will be immediately called, passing it the mode constant PRStateModeEnd.  After that, the object's current state script will be called passing it PRStateModeInit as its argument.  Then, for every frame update (step), the object's current state script will be called with its mode argument set to PRStateModeUpdate. Parameters:    obj: The object to set the state for.   stateName: The name of the state to add.  Must have been previously added to the object using PRStateAdd.    optionalData1: Arbitrary data to store for the given state.  To be used at your discretion. (Optional)   optionalData2: Arbitrary data to store for the given state.  To be used at your discretion. (Optional)   optionalData3: Arbitrary data to store for the given state.  To be used at your discretion. (Optional)Return Value:    true if the state was set, false otherwise. PRStateSetPrev(obj) Shortcut to set the current state of the object to whatever its previous state was using its previous state optional data, if it has any.  Calls PRSetState for you internally. Parameters:    obj: The object to set the state for.Return Value:    true if the state was set, false otherwise. PRStateSetVerbose(verboseActive) Turns on or off the current object's debug verbosity.  When on, state changes and failures will be written to the output console in GameMaker Studio to aid in debugging.Parameters:    verboseActive: To turn on debug verbosity, set to true.  Otherwise, set it to false. Return Value:    n/a PRStateUpdate() Is called once every frame (step) which runs the object's current state script with its mode argument set to PRStateModeUpdate.  Call this function once in your object's Step event. Parameters:    n/a Return Value:    n/a

PRActionEaseQuadraticOut

PRVircon Directions

PRVirconBtnIsPressed

PRVircon Axes

PRVirconJoyPressed(joyId, joyDir) Returns true if the joystick is being pressed in the given direction and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. joyDir The direction requested.  Can be one of the following constant values: PRVirconDirRight, PRVirconDirUpRight, PRVirconDirUp, PRVirconDirUpLeft, PRVirconDirLeft, PRVirconDirDownLeft, PRVirconDirDown, PRVirconDirDownRight. Return Value: true or false

PRVirconBtnSetRotation(btnId, rotation) Sets the rotation angle for the given button's sprite when drawn. Parameters:btnId The button ID. rotation The rotation angle. Return Value: n/a

PRVirconBtnSetIsToggle(btnId, isToggle) Sets whether or not the given button should behave like a toggle button.  If true the button stays pressed when the player presses it, requiring the player to press it again to return it to its unpressed state.  If false, the button automatically returns to its unpressed state when the player lets go of it. Parameters:btnId The button ID. isToggle true if a toggle button is desired, false otherwise. Return Value: n/a

PRVirconBtnSetLabelOffset(btnId, xOffset, yOffset) Sets the given button's label offset coordinates.  Use this function to reposition the label within the button, or outside of the button.  If positioning outside of the button's body, you should probably turn off the label's scaling effect when the button is pressed.  Use the PRVirconBtnSetLabel function to do so. Parameters:btnId The button ID. xOffset The x-offset of the label sprite from the center of the button. yOffset The y-offset of the label sprite from the center of the button. Return Value: n/a

PRActionEaseQuadraticInOut

PRActionDestroy

PRVirconBtnSetLabel(btnId, sprite, xOffsetX, yOffset, scale, shouldScaleWhenSel, rotation) Sets the given buttons's label sprite. Parameters:btnId The button ID. sprite The sprite to use for the button's label. xOffset The x-offset of the label sprite from the center of the button. yOffset The y-offset of the label sprite from the center of the button. scale The scale size to apply to the label sprite with 1 being normal size. shouldScaleWhenSel true or false indicating if the label should scale when the button is pressed.  Useful for when the label is positioned outside of the button's body. rotation The angle at which to draw the label sprite. Return Value: n/a

PRVirconBtnGetRotation

Customizing Joysticks After you’ve added a virtual joystick and captured its ID, you can further customize its look and behaviour using additional functions.  Joysticks are made up of the following components:      • The nub: The moveable area that the player drags with his/her thumb.     • The outline: The outer container representing the area limits of the nub's movement.     • The notches: The 8 cardinal points around the joystick.     • The label: A label to display on the nub. For example, you can set a label sprite on the joystick like this: PRVirconJoySetLabel(joyId, sPRVircon_Joy1_Lbl4Arrows, 0, 0, 1, 45); The above code adds a Style 1 "4 Arrows" label to the joystick identified by joyId at a 45 degree angle.  You could, of course, use your own custom sprite instead. More coming soon.

PRVirconBtnGetTouchRadius

PRVirconJoyIsUpRight(joyId) Returns true if the joystick is being pressed up-right and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionEaseQuadraticIn

PRVirconDirDown Specifies the down direction. PRVirconDirDownLeft Specifies the down-left direction. PRVirconDirDownRight Specifies the down-right direction. PRVirconDirLeft Specifies the left direction. PRVirconDirRight Specifies the right direction. PRVirconDirUp Specifies the up direction. PRVirconDirUpLeft Specifies the up-left direction. PRVirconDirUpRight Specifies the up-right direction.

PRVirconBtnIsDown

Defined Constants

Instance Variables PRVircon exposes no public instance variables.

PRVirconBtnGetTouchRadius(btnId) Returns the given button's touch radius size in pixels. Parameters:btnId The button ID. Return Value: The touch radius size in pixels, unmodified by the scale size of the button.

PRActionInit

PRVirconBtnSetBlend(btnId, buttonBlendColor, labelBlendColor) Sets the blend color to use for the given button's sprite and its label sprite. Parameters:btnId The button ID. buttonBlendColor The blend color to use for the button's sprite. labelBlendColor The blend color to use for the button's label sprite. Return Value: n/a

Customizing Buttons Coming soon. 

PRVirconBtnGetIsToggle

PRVirconJoyIsUpLeft(joyId) Returns true if the joystick is being pressed up-left and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRVirconBtnGetToggleState(btnId) Returns true if the toggle button is currently pressed, false if not.  If the button is not set as a toggle button, will always return false. Parameters:btnId The button ID. Return Value: true or false

PRActionScaleYBy(scaleBy, easeId, durationSecs) Creates an action object of type PRActionTypeScaleYBy.  When this action is played by an object, that object's image_yscale variable will animate from it's current value by the amount given in scaleBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: scaleBy The relative amount that the object's image_yscale variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRVirconBtnGetScale(btnId) Returns the scale value of the given button's sprite. Parameters:btnId The button ID. Return Value: The scale value of the button's sprite.

Reading Input Coming soon. 

PRVirconJoyIsUp(joyId) Returns true if the joystick is being pressed up and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionScaleXTo(scaleTo, easeId, durationSecs) Creates an action object of type PRActionTypeScaleXTo.  When this action is played by an object, that object's image_xscale variable will animate from it's current value to the given scaleTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: scaleTo The absolute value that the object's image_xscale variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRVirconSetAlpha

PRVirconBtnIsPressed(btnId) Returns true if the button was pressed down in the current frame.  false otherwise. Parameters:btnId The button ID. Return Value: true or false

PRVirconJoySetLabelOffset(joyId, xOffset, yOffset) Sets the given joystick's label offset coordinates. Parameters:joyId The joystick ID. xOffset The x-offset of the label sprite from the center of the joystick's nub. yOffset The y-offset of the label sprite from the center of the joystick's nub. Return Value: n/a

PRVirconBtnGetIsToggle(btnId) Returns whether or not the given button is set as a toggle button. Parameters:btnId The button ID. Return Value: true or false

PRActionScaleXBy(scaleBy, easeId, durationSecs) Creates an action object of type PRActionTypeScaleXBy.  When this action is played by an object, that object's image_xscale variable will animate from it's current value by the amount given in scaleBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: scaleBy The relative amount that the object's image_xscale variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRVirconBtnGetRotation(btnId) Returns the rotation value of the given button's sprite. Parameters:btnId The button ID. Return Value: The rotation value of the button's sprite.

UI Control Coming soon. 

PRVirconJoyIsRight(joyId) Returns true if the joystick is being pressed right and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionScaleTo(scaleTo, easeId, durationSecs) Creates an action object of type PRActionTypeScaleTo.  When this action is played by an object, that object's image_xscale and image_yscale variables will animate from their current values to the given scaleTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variables while the action is playing.  Doing so will result in animation jerkiness as the action corrects the values at each frame (step) update. Parameters: scaleTo The absolute value that the object's image_xscale and image_yscale variables will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRVirconGetVisible

PRVirconBtnIsReleased(btnId) Returns true if the button was released in the current frame.  false otherwise. Parameters:btnId The button ID. Return Value: true or false

PRVirconBtnGetName(btnId) Returns the given button's name. Parameters:btnId The button ID. Return Value: The name of the button.

PRActionEaseLinear

PRActionScaleBy(scaleBy, easeId, durationSecs) Creates an action object of type PRActionTypeScaleBy.  When this action is played by an object, that object's image_xscale and image_yscale variables will animate from their current values by the amount given in scaleBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variables in mid-process.  The object will adapt to whatever new values are set at each frame (step) update. Parameters: scaleBy The relative amount that the object's image_xscale and image_yscale variables will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variables. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final values in 1 frame (step). Return Value: The created action object.

PRVirconBtnGetLabelYOffset(btnId) Returns the y-offset of the given button's label sprite. Parameters:btnId The button ID. Return Value: The label sprites's y-offset value.

PRVirconJoyIsLeft(joyId) Returns true if the joystick is being pressed left and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionEaseExponentialOut

PRVirconSetVisible

PRActionScaleYTo(scaleTo, easeId, durationSecs) Creates an action object of type PRActionTypeScaleYTo.  When this action is played by an object, that object's image_yscale variable will animate from it's current value to the given scaleTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: scaleTo The absolute value that the object's image_yscale variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

Adding Joysticks

PRActionEaseExponentialInOut

PRVirconBtnGetLabelXOffset(btnId) Returns the x-offset of the given button's label sprite. Parameters:btnId The button ID. Return Value: The label sprites's x-offset value.

PRActionRotateTo(rotateTo, easeId, durationSecs) Creates an action object of type PRActionTypeRotateTo.  When this action is played by an object, that object's image_angle variable will animate from it's current value to the given rotateTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: rotateTo The absolute value that the object's image_angle variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

Customizing Joysticks

PRVirconJoyIsDownRight(joyId) Returns true if the joystick is being pressed down-right and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionEaseExponentialIn

PRVirconGetActive

Core Functions

PRActionRotateBy(rotateBy, easeId, durationSecs) Creates an action object of type PRActionTypeRotateBy.  When this action is played by an object, that object’s image_angle variable will animate from it's current value by the amount given in rotateBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: rotateBy The relative amount that the object's image_angle variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionEaseCubicOut

PRActionMoveYTo(moveToY, easeId, durationSecs) Creates an action object of type PRActionTypeMoveYTo.  When this action is played by an object, that object's y variable will animate from it's current value to the given moveToY value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: moveToY The absolute value that the object's y variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

Customizing Buttons

PRVirconJoyIsDownLeft(joyId) Returns true if the joystick is being pressed down-left and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionEaseCubicInOut

PRVirconSetActive

PRActionPause

PRActionMoveYBy(moveByY, easeId, durationSecs) Creates an action object of type PRActionTypeMoveYBy.  When this action is played by an object, that object’s y variable will animate from it's current value by the amount given in moveByY using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: moveByY The relative amount that the object's y variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final values in 1 frame (step). Return Value: The created action object.

PRActionEaseCubicIn

PRActionPlay

PRVirconSetGUISize

PRActionEaseCircularOut

PRActionResume

PRActionEaseCircularInOut

PRActionStatus

PRVirconGetGUIWidth

PRActionEaseCircularIn

PRActionStop

PRActionMoveXTo(moveToX, easeId, durationSecs) Creates an action object of type PRActionTypeMoveXTo.  When this action is played by an object, that object's x variable will animate from it's current value to the given moveToX value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: moveToX The absolute value that the object's x variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionMoveXBy(moveByX, easeId, durationSecs) Creates an action object of type PRActionTypeMoveXBy.  When this action is played by an object, that object’s x variable will animate from it's current value by the amount given in moveByX using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: moveByX The relative amount that the object's x variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionAlphaBy

PRActionMoveTo(moveToX, moveToY, easeId, durationSecs) Creates an action object of type PRActionTypeMoveTo.  When this action is played by an object, that object's x and y variables will animate from their current values to the given moveToX and moveToY values using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variables while the action is playing.  Doing so will result in animation jerkiness as the action corrects the values at each frame (step) update. Parameters: moveToX The absolute value that the object's x variable will be changed to by the end of the animation. moveToY The absolute value that the object's y variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

Standard Action Functions

PRActionPlayAction(obj, action) Creates an action object of type PRActionTypePlayAction.  When this action is played by an object, it will trigger the given action in action to play.  The given action will play within the context of the given object. Parameters: obj The object that will run the action. action The action that the object will play. Return Value: The created action object.

PRActionCustomScript2

PRActionEaseBackOut

PRActionWait(durationSecs) Creates an action object of type PRActionTypeWait.  When this action is played by an object, it will perform no action.  Useful to add a delay before, in the middle of, and/or after other actions in an action sequence. Parameters: durationSecs The length of time that the action will do nothing for. Return Value: The created action object.

PRActionCustomScript1

PRActionStopAll

PRActionEaseBackInOut

PRActionUnhide() Creates an action object of type PRActionTypeUnhide.  When this action is played by an object, that object's visible variable will instantly change to true. Parameters: n/a Return Value: The created action object.

PRActionCustomColorVar

PRActionUpdate

PRActionEaseBackIn

PRActionStopSound(soundId) Creates an action object of type PRActionTypeStopSound.  When this action is played by an object, the sound identified by the given soundId will stop playing. Parameters: soundId The sound to stop playing. Return Value: The created action object.

PRActionCustomColorScript

Additional Functions

Easing Functions

PRActionStopAllSounds(soundId) Creates an action object of type PRActionTypeStopAllSounds.  When this action is played by an object, all playing sounds will stop playing. Parameters: n/a Return Value: The created action object.

PRActionMoveYBy

PRActionPlayCount(obj) Returns the total number of active actions for the given object that are currently either playing or paused. Parameters: obj The object instance. Return Value: The number of currently playing/paused actions.

PRActionStopAction(obj, slotIndexOrName) Creates an action object of type PRActionTypeStopAction  When this action is played by an object, it will instantly stop playing the action found in the given object's slot index.  Or if an action name is provided instead, all of the given object's playing actions matching that name will be stopped instantly. Parameters: obj The object whose action(s) will stop playing. slotIndexOrName The slot index or action name of the action(s) to stop playing. Return Value: The created action object.

PRActionMoveXTo

PRActionDestroy() Uninitializes all PRAction-related data from the current object.  Call this once in your object's Destroy event. Parameters: n/a Return Value: n/a

PRActionSetData1(action, data1) Allows the changing of the data1 property of the given action.  This affects certain easing functions. Parameters: action The action object whose data1 property to set. data1 The numeric value to set. Return Value: n/a

PRActionSpriteIndex(spriteIndex, imageIndex) Creates an action object of type PRActionTypeSpriteIndex.  When this action is played by an object, the object's sprite_index and/or image_index instance variables will be changed instantly to the given spriteIndex and imageIndex values, respectively. Parameters: spriteIndex The value to change the object's sprite_index variable to.  Specifying noone here will cause no change to the sprite_index variable. imageIndex The value to change the object's image_index variable to.  Specifying noone here will cause no change to the image_index variable. Return Value: The created action object.

PRActionMoveXBy

PRActionSetData2(action, data2) Allows the changing of the data2 property of the given action.  This affects certain actions differently. Parameters: action The action object whose data2 property to set. data2 The numeric value to set. Return Value: n/a

PRActionMoveTo

PRActionSetEase(action, easeId) Changes the ease function used for the given action.  Does not affect container-type actions.  Will cause an error if an undefined ease ID is provided. Parameters: action The action object whose ease function to set. easeId The ease ID to set.  Must be one of the defined PRAction ease ID constants. Return Value: n/a

PRActionBlendTo(blendTo, easeId, durationSecs) Creates an action object of type PRActionTypeBlendTo.  When this action is played by an object, that object's image_blend variable will animate from it's current value to the given blendTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: blendTo The absolute value that the object's image_blend variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionBlendBy(blendBy, easeId, durationSecs) Creates an action object of type PRActionTypeBlendBy.  When this action is played by an object, that object's image_blend variable will animate from it's current value by the amount given in blendBy using the easing equation identified by easeId over a duration of durationSecs seconds. Please note that by default, this action will not let the red, green and blue components of the color being animated to go below 0 or above 255.  If, for some reason, this behaviour is desired, set this action's data2 property to false using the PRActionSetData2 function. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: blendBy The relative amount that the object's image_blend variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRAction Ease IDs

PRActionPause(obj) Pauses all currently running actions for the given object.  Changes the object's current PRAction status to PRActionStatusPaused.  Actions can then be resumed using PRActionResume. Parameters: obj The object instance for which all actions will be paused. Return Value: n/a

PRAction Types

PRAction Statuses

PRActionRunUserEvent(eventNumber) Creates an action object of type PRActionTypeRunUserEvent.  When this action is played by an object, the user event identified by eventNumber will be run. Parameters: eventNumber The user event number to run. Return Value: The created action object.

PRActionMoveBy

PRActionRunScript(scriptId, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ) Creates an action object of type PRActionTypeRunScript.  When this action is played by an object, the given script identified by scriptId will be run, optionally passing it up to 8 given arguments. Parameters: scriptId The script that will run. arg1 - arg8 Optional arguments that will be given to the script when it's called. Return Value: The created action object.

PRActionImageSpeedTo

PRActionPlaySound(soundId, priority, loops) Creates an action object of type PRActionTypePlaySound.  When this action is played by an object, the sound identified by the given id soundId will start playing. Parameters: soundId The sound that will play. priority The channel priority of the sound. loops Boolean value indicating if the sound should loop or not. Return Value: The created action object.

PRActionImageSpeedBy

PRActionHide() Creates an action object of type PRActionTypeHide.  When this action is played by an object, that object's visible variable will instantly change to false. Parameters: n/a Return Value: The created action object.

PRActionAlphaTo(alphaTo, easeId, durationSecs) Creates an action object of type PRActionTypeAlphaTo.  When this action is played by an object, that object's image_alpha variable will animate from it's current value to the given alphaTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: alphaTo The absolute value that the object's image_alpha variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionDepthTo(depthTo) Creates an action object of type PRActionTypeDepthTo.  When this action is played by an object, that object's depth variable will instantly change to the value given in depthTo. Parameters: depthTo The value that the object's depth variable will change to. Return Value: The created action object.

PRActionCustomVar

PRActionAlphaBy(alphaBy, easeId, durationSecs) Creates an action object of type PRActionTypeAlphaBy.  When this action is played by an object, that object's image_alpha variable will animate from it's current value by the amount given in alphaBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: alphaBy The relative amount that the object's image_alpha variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionDepthBy(depthBy) Creates an action object of type PRActionTypeDepthBy.  When this action is played by an object, that object's depth variable will instantly change by the value given in depthBy. Parameters: depthBy The relative amount that the object's depth variable change by. Return Value: The created action object.

PRActionScaleYBy

PRActionMoveBy(moveByX, moveByY, easeId, durationSecs) Creates an action object of type PRActionTypeMoveBy.  When this action is played by an object, that object’s x and y variables will animate from it's current values by the amounts given in moveByX and moveByY using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variables in mid-process.  The object will adapt to whatever new values are set at each frame (step) update. Parameters: moveByX The relative amount that the object's x variable will be changed by the end of the animation. moveByY The relative amount that the object's y variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variables. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final values in 1 frame (step). Return Value: The created action object.

PRActionPlay(obj, action, optionalName) Plays the given action within the context of the given object.  The action object can be reused (played) again for this or any other object at any point in time.  Provide an optional name that can be used to reference the playing action later on with PRActionStop.  There is no limit to the number of actions that can be played for a given object.  Each additional action played will not interrupt other currently playing actions. Parameters: obj The object instance that will play the given action. action The action object previously created with one of the action creation functions. optionalName A name string given to the action while it's playing.  Can be used to reference the playing action at a later time. (Optional) Return Value: The slot id that the action is assigned while it's playing within the context of the object.  Can be used to reference the playing action at a later time.

PRActionChangeLayer(layerName) Creates an action object of type PRActionTypeChangeLayer.  When this action is played by an object, that object’s layer variable will instantly change to the layer identified with the name layerName.  If that layer isn't found when this action is run, nothing will happen. Parameters: layerName The name of the layer that the object will move to. Return Value: The created action object.

PRActionScaleXTo

PRActionImageSpeedTo(imageSpeedTo, easeId, durationSecs) Creates an action object of type PRActionTypeImageSpeedTo.  When this action is played by an object, that object's image_speed variable will animate from it's current value to the given imageSpeedTo value using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: blendTo The absolute value that the object's image_speed variable will be changed to by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionResume(obj) Resumes running the object's actions that were previously paused using PRActionPause.  Changes the object's current PRAction status to PRActionStatusPlaying. Parameters: obj The object instance whose paused actions will be resumed. Return Value: n/a

PRActionSequenceArr(actionArray) Creates an action object of type PRActionTypeSequence.  A sequence action is a container that holds one or more other actions.  When this action is played by an object, all of the actions within the sequence action are played in sequence one at a time.  Sequence actions do not stop playing until all of the actions in the sequence have completed.  Sequence actions may contain other nested container actions. Parameters: actionArray An array of actions to place into the sequence action container. Return Value: The created action object.

PRActionScaleXBy

PRActionEaseIdBackInSpecifies a "Back In" easing equation, which causes an animation to start off slowly, reversing briefly at first, and then speed up as it progresses. PRActionEaseIdBackInOutSpecifies a "Back In/Out" easing equation, in which the first half of the animation's motion uses the "Back In" equation and the second half uses the "Back Out” equation. PRActionEaseIdBackOutSpecifies a "Back Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, and finally plays in reverse briefly as it comes to a stop. PRActionEaseIdCircularInSpecifies a "Circular In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a more dramatic curve than the quadratic equation. PRActionEaseIdCircularInOutSpecifies a "Circular In/Out" easing equation, in which the first half of the animation's motion uses the "Circular In" equation and the second half uses the "Circular Out” equation. PRActionEaseIdCircularOutSpecifies a "Circular Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a more dramatic curve than the quadratic equation. PRActionEaseIdCubicIn Specifies a "Cubic In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using only a slighty more dramatic curve than the sinusoidal equation. PRActionEaseIdCubicInOutSpecifies a "Cubic In/Out" easing equation, in which the first half of the animation's motion uses the "Cubic In" equation and the second half uses the "Cubic Out” equation. PRActionEaseIdCubicOutSpecifies a "Cubic Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using only a slightly more dramatic curve than the sinusoidal equation. PRActionEaseIdExponentialInSpecifies an "Exponential In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a more dramatic curve than the quintic equation. PRActionEaseIdExponentialInOutSpecifies an "Exponential In/Out" easing equation, in which the first half of the animation's motion uses the "Exponential In" equation and the second half uses the "Exponential Out" equation. PRActionEaseIdExponentialOutSpecifies an "Exponential Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a more dramatic curve than the quintic equation. PRActionEaseIdLinear Specifies "Linear" easing.  Linear easing causes an animation to occur evenly over its duration. PRActionEaseIdQuadraticIn Specifies a "Quadratic In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a slighty more dramatic curve than the cubic equation. PRActionEaseIdQuadraticInOutSpecifies a "Quadratic In/Out" easing equation, in which the first half of the animation's motion uses the "Quadratic In" equation and the second half uses the "Quadratic Out" equation. PRActionEaseIdQuadraticOutSpecifies a "Quadratic Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a slightly more dramatic curve than the cubic equation. PRActionEaseIdQuarticIn Specifies a "Quartic In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a more dramatic curve than the circular equation. PRActionEaseIdQuarticInOutSpecifies a "Quartic In/Out" easing equation, in which the first half of the animation's motion uses the "Quartic In" equation and the second half uses the "Quartic Out" equation. PRActionEaseIdQuarticOutSpecifies a "Quartic Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a more dramatic curve than the circular equation. PRActionEaseIdQuinticIn Specifies a "Quintic In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a more dramatic curve than the quartic equation. PRActionEaseIdQuinticInOutSpecifies a "Quintic In/Out" easing equation, in which the first half of the animation's motion uses the "Quintic In" equation and the second half uses the "Quintic Out" equation. PRActionEaseIdQuinticOutSpecifies a "Quintic Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a more dramatic curve than the quartic equation. PRActionEaseIdSinusoidalIn Specifies a "Sinusoidal In" easing equation, which causes an animation to start off slowly at first and then speed up as it progresses, using a gentle sine curve. PRActionEaseIdSinusoidalInOutSpecifies a "Sinusoidal In/Out" easing equation, in which the first half of the animation's motion uses the "Sinusoidal In" equation and the second half uses the "Sinusoidal Out" equation. PRActionEaseIdSinusoidalOutSpecifies a "Sinusoidal Out" easing equation, which causes an animation to begin quickly and then slow down as it completes, using a gentle sine curve.

PRActionImageSpeedBy(imageSpeedBy, easeId, durationSecs) Creates an action object of type PRActionTypeImageSpeedBy.  When this action is played by an object, that object's image_speed variable will animate from it's current value by the amount given in imageSpeedBy using the easing equation identified by easeId over a duration of durationSecs seconds. As this is a relative animation, it is possible to alter the object's animating variable in mid-process.  The object will adapt to whatever new value is set at each frame (step) update. Parameters: imageSpeedBy The relative amount that the object's image_speed variable will be changed by the end of the animation. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionSequence(action1, action2, action3, ...) Creates an action object of type PRActionTypeSequence.  A sequence action is a container that holds one or more other actions.  When this action is played by an object, all of the actions within the sequence action are played in sequence one at a time.  Sequence actions do not stop playing until all of the actions in the sequence have completed.  Sequence actions may contain other nested container actions. Parameters: action1, action2, action3, ... The actions to place into the sequence action container. Return Value: The created action object.

PRActionScaleTo

PRActionStatus(obj) Returns the object's current PRAction status. Parameters: obj The object instance whose PRAction status is returned. Return Value: Returns either PRActionStatusPlaying, PRActionStatusPaused or PRActionStatusStopped depending on whether the object's actions are current playing, paused or stopped, respectively.

PRActionCustomVar(varName, fromValue, toValue, easeId, durationSecs) Creates an action object of type PRActionTypeCustomVar.  When this action is played by an object, the instance variable in that object identified with the name varName will animate from the value given in fromValue to the value given in toValue using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: varName The name of the instance variable to animate. fromValue The value that the custom variable will start at when the animation begins. toValue The value that the custom variables will end up being when the animation is complete. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionStop(obj, slotIndexOrName) Stops an object's playing action identified by the given slot number.  Or, if a name is provided instead, stops all of the object's playing actions with the given name.  If the object no longer has any playing objects after this function is called, the object's PRAction status will be set to PRActionStatusStopped. Parameters: obj The object instance whose playing action(s) will be stopped. slotIndexOrName A slot index number or name string identifying one or more playing actions. Return Value: n/a

PRActionRepeatForever(action) Creates an action object of type PRActionTypeRepeater.  This repeat action is a container that, when played by an object, will repeatedly play the contained action an unlimited number of times.  This action doesn't stop playing until it is stopped using the PRActionStop function.  The action being repeated can be any action including container actions. Parameters: action The action to repeat forever. Return Value: The created action object.

PRActionScaleBy

PRActionCustomScript2(scriptId, fromValue1, fromValue2, toValue1, toValue2, easeId, durationSecs) Creates an action object of type PRActionTypeCustomScript2.  When this action is played by an object, the script identified by scriptId will be called once per frame (step) and will be given 2 numeric arguments that will animate from the values given in fromValue1 and fromValue2 to the values given in toValue1 and toValue2 using the easing equation identified by easeId over a duration of durationSecs seconds.  The script will run within the context of the object running the action. Parameters: scriptId The script resource id to call at each frame (step) throughout the animation. fromValue1 The value that the first value starts at when the animation begins. fromValue2 The value that the second value starts at when the animation begins. toValue1 The value that the first value ends up at when the animation is complete. toValue2 The value that the second value ends up at when the animation is complete. easeId The ease ID identifying the easing equation to use when animating the values. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final values in 1 frame (step). Return Value: The created action object.

PRActionRotateTo

PRActionStopAll(obj) Stops all running actions for the given object.  The object's PRAction status will be set to PRActionStatusStopped. Parameters: obj The object instance whose playing action(s) will be stopped. Return Value: n/a

PRActionCustomScript1(scriptId, fromValue, toValue, easeId, durationSecs) Creates an action object of type PRActionTypeCustomScript1.  When this action is played by an object, the script identified by scriptId will be called once per frame (step) and will be given 1 numeric argument that will animate from the value given in fromValue to the value given in toValue using the easing equation identified by easeId over a duration of durationSecs seconds.  The script will run within the context of the object running the action. Parameters: scriptId The script resource id to call at each frame (step) throughout the animation. fromValue The value to start the animation at. toValue The value to end up at when the animation is complete. easeId The ease ID identifying the easing equation to use when animating the value. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionUpdate() Updates all of the current object's playing actions for the current frame (step).  Call this once in your object's Step event. Parameters: n/a Return Value: n/a

PRActionCustomColorVar(varName, fromColor, toColor, easeId, durationSecs) Creates an action object of type PRActionTypeCustomColorVar.  When this action is played by an object, the color-type instance variable in that object identified with the name varName will animate from the color value given in fromValue to the value given in toValue using the easing equation identified by easeId over a duration of durationSecs seconds. As this is an absolute animation, it is not recommended to alter the object's animating variable while the action is playing.  Doing so will result in animation jerkiness as the action corrects the value at each frame (step) update. Parameters: varName The name of the color-type instance variable to animate. fromValue The value that the custom variable will start at when the animation begins. toValue The value that the custom variables will end up being when the animation is complete. easeId The ease ID identifying the easing equation to use when animating the object's variable. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionQBlink

PRActionCustomColorScript(scriptId, fromColor, toColor, easeId, durationSecs) Creates an action object of type PRActionTypeCustomColorScript.  When this action is played by an object, the script identified by scriptId will be called once per frame (step) and will be given 1 color-type argument that will animate from the value given in fromValue to the value given in toValue using the easing equation identified by easeId over a duration of durationSecs seconds.  The script will run within the context of the object running the action. Parameters: scriptId The script resource id to call at each frame (step) throughout the animation. fromColor The color value to start the animation at. toColor The color value to end up at when the animation is complete. easeId The ease ID identifying the easing equation to use when animating the value. durationSecs The total length of time (in seconds) that the animation will take before completing.  Specifying 0 here will result in an instant change to the final value in 1 frame (step). Return Value: The created action object.

PRActionTypeAlphaBy Specifies an alpha by action.  This type of action causes an object's image_alpha property to animate by a given amount relative to it's current value. PRActionTypeAlphaTo Specifies an alpha to action.  This type of action causes an object's image_alpha property to animate to a given absolute amount. PRActionTypeBlendBy Specifies an image blend by action.  This type of action causes an object's image_blend property to animate by a given amount relative to it's current value. PRActionTypeBlendTo Specifies an image blend to action.  This type of action causes an object's image_blend property to animate to a given absolute amount. PRActionTypeChangeLayer Specifies a change layer action.  This type of action instantly causes an object’s layer property to change to the given value. PRActionTypeCustomColorScript Specifies a custom color script action.  This type of action runs the given script at each frame (step), passing it a color-type argument that is updated each frame until the destination (to) value is reached. PRActionTypeCustomColorVar Specifies a custom color variable action.  This type of action animates/updates the given color-type instance variable at each frame (step), until the destination (to) value is reached. PRActionTypeCustomScript1 Specifies a 1-argument custom script action.  This type of action runs the given script at each frame (step), passing it one numeric-type argument that is updated each frame until the destination (to) value is reached. PRActionTypeCustomScript2 Specifies a 2-argument custom script action.  This type of action runs the given script at each frame (step), passing it two numeric-type arguments that are updated each frame until the destination (to) values are reached. PRActionTypeCustomVar Specifies a custom variable action.  This type of action animates/updates the given numeric-type instance variable at each frame (step), until the destination (to) value is reached. PRActionTypeDepthBy Specifies a depth by action.  This type of action causes an object's depth property to animate by a given amount relative to it's current value. PRActionTypeDepthTo Specifies a depth to action.  This type of action causes an object's depth property to animate to a given absolute amount. PRActionTypeGroup Specifies a group action.  This type of action is a container that causes the actions within it to play simultaneously.  The actions within can be other container actions. PRActionTypeHide Specifies a hide action.  This type of action instantly causes an object’s visible property to change to false. PRActionTypeImageSpeedBy Specifies an image speed by action.  This type of action causes an object's image_speed property to animate by a given amount relative to it's current value. PRActionTypeImageSpeedTo Specifies an image speed to action.  This type of action causes an object's image_speed property to animate to a given absolute amount. PRActionTypeMoveBy Specifies a move by action.  This type of action causes an object's x and y properties to animate by given amounts relative to it's current values. PRActionTypeMoveTo Specifies a move to action.  This type of action causes an object's x and y properties to animate to given absolute amounts. PRActionTypeMoveXBy Specifies a move X by action.  This type of action causes an object's x property to animate by a given amount relative to it's current value. PRActionTypeMoveXTo Specifies a move X to action.  This type of action causes an object's x property to animate to a given absolute amount. PRActionTypeMoveYBy Specifies a move Y by action.  This type of action causes an object's y property to animate by a given amount relative to it's current value. PRActionTypeMoveYTo Specifies a move Y to action.  This type of action causes an object’s y property to animate to a given absolute amount. PRActionTypePlayAction Specifies a play action action.  This type of action instantly causes the given action to play. PRActionTypePlaySound Specifies a play sound action.  This type of action instantly causes the given sound to play. PRActionTypeRepeater Specifies a repeat action.  This type of action is a container that causes the action within it to play repeatedly.  The action within can be another container action. PRActionTypeRotateBy Specifies a rotate by action.  This type of action causes an object's image_angle property to animate by a given amount relative to it's current value. PRActionTypeRotateTo Specifies a rotate to action.  This type of action causes an object's image_angle property to animate to a given absolute amount. PRActionTypeRunScript Specifies a run script action.  This type of action instantly runs the given script with up to 8 optional arguments. PRActionTypeRunUserEvent Specifies a run user event action.  This type of action instantly runs the given user event. PRActionTypeScaleBy Specifies a scale by action.  This type of action causes an object's image_xscale and image_yscale properties to animate by given amounts relative to it's current values. PRActionTypeScaleTo Specifies a scale to action.  This type of action causes an object's image_xscale and image_yscale properties to animate to given absolute amounts. PRActionTypeScaleXBy Specifies a scale X by action.  This type of action causes an object's image_xscale property to animate by a given amount relative to it's current value. PRActionTypeScaleXTo Specifies a scale X to action.  This type of action causes an object's image_xscale property to animate to a given absolute amount. PRActionTypeScaleYBy Specifies a scale Y by action.  This type of action causes an object's image_yscale property to animate by a given amount relative to it's current value. PRActionTypeScaleYTo Specifies a scale Y to action.  This type of action causes an object's image_yscale property to animate to a given absolute amount. PRActionTypeSequence Specifies a sequence action.  This type of action is a container that causes the actions within it to play in sequence.  The actions within can be other container actions. PRActionTypeSpriteIndex Specifies a sprite index action.  This type of action instantly causes an object’s sprite_index and/or image_index properties to change to the given value(s). PRActionTypeStopAction Specifies a stop action action.  This type of action instantly causes the given action to stop playing. PRActionTypeStopSound Specifies a stop sound action.  This type of action instantly causes the given sound to stop playing. PRActionTypeStopAllSounds Specifies a stop sound all sounds action.  This type of action instantly causes all currently playing sounds to stop playing. PRActionTypeUnhide Specifies an unhide action.  This type of action instantly causes an object’s visible property to change to true. PRActionTypeWait Specifies a wait action.  This type of action does nothing (waits) for the given length of time.

PRActionQBlink(startVisible, visibleDurationSecs, invisibleDurationSecs) Creates a compound action that, when played by an object, will blink the object repeatedly by twiddling the object's visibility. Parameters: startVisible A boolean value that indicates if the object should start out visible (true) or if it should start invisible (false). visibleDurationSecs The time, in seconds, that the object should remain visible. invisibleDurationSecs The time, in seconds, that the object should remain invisible. Return Value: The created action object.

PRActionStatusPaused Specifies the paused status.  An object that conforms to PRAction that is currently in this status indicates that all assigned actions are currently not running, but may be resumed at any time. PRActionStatusPlayingSpecifies the playing status.  An object that conforms to PRAction that is currently in this status indicates that all assigned actions are currently playing as normal. PRActionStatusStoppedSpecifies the stopped status.  An object that conforms to PRAction that is currently in this status indicates that all assigned actions are currently not playing and cannot be resumed.

PRActionRepeat(action, repeatCount) Creates an action object of type PRActionTypeRepeater.  A repeat action is a container that, when played by an object, will repeatedly play the contained action the given number of times in repeatCount.  This action doesn't stop playing until all of the repeat cycles are done playing.  The action being repeated can be any action including container actions. Parameters: action The action to repeat. repeatCount The number of times to repeat the action when it's played. Return Value: The created action object.

PRActionGroup(action1, action2, action3, ...) Creates an action object of type PRActionTypeGroup.  A group action is a container that holds one or more other actions.  When this action is played by an object, all of the actions within the group are played simultaneously.  Group actions do not stop playing until all of the actions in the group have stopped playing.  Group actions may contain other nested container actions. Parameters: action1, action2, action3, ... The actions to place into the group action container. Return Value: The created action object.

PRActionRotateBy

PRActionQWobble(travelDegrees, repeatCount, easeId, durationPerWobbleSecs) Creates a compound action that, when played by an object, will wobble the object using back and forth rotation. Parameters: travelDegrees The total number of degrees that the wobble will travel. repeatCount The number of wobbles to do.  Specify a negative number here for infinite wobbling. easeId The ease id indicating which easing function to use for this animation. durationPerWobbleSecs The time, in seconds, that it takes for each full wobble to occur. Return Value: The created action object.

PRActionMoveYTo

PRActionQSlideFade(moveXBy, moveYBy, alphaTo, easeId, durationSecs) Creates a compound action that, when played by an object, will move the object by the given x and y distances while fading the object in or out.  Ensure that the object currently has the desired starting image_alpha value prior to running this action. Parameters: moveXBy The distance to move the object by in the x direction. moveYBy The distance to move the object by in the y direction. alphaTo The alpha value that the object will transition to during the animation. easeId The ease id indicating which easing function to use for this animation. durationSecs The time, in seconds, that it takes for the animation to occur. Return Value: The created action object.

Creating Compound Actions After creating a few simple actions, you are probably ready for something more.  Compound actions are actions that are combined together to create more complex animations, and that's where things start getting really interesting! PRAction has a few built-in compound actions to get you started quickly.  Let's have a look at one: var bounce = PRActionQBounce(40, 90, 0, PRActionEaseIdCubicOut, PRActionEaseIdCubicIn, 1); The above code creates an action that, when played by an object, will bounce that object repeatedly up and down.  So, why is this a compound action?  Well, because it creates an upward movement action and a downward movement action, then it puts them together in sequence, and then repeats that sequence forever.  This introduces two new concepts: Sequence actions and Repeater actions. Sequence actions is a container type of action that allows you to string together multiple actions that will play one after the other in sequence.  Creating one is simple.  Let's begin creating a simple bounce action of our own.  First, we will need the 2 movement actions: var moveDown = PRActionMoveYBy(40, PRActionEaseIdCubicIn, 0.5); var moveUp = PRActionMoveYBy(-40, PRActionEaseIdCubicOut, 0.5); Now, we will want to play those 2 actions one after the other.  To do this, we need a sequence action.  Let’s do that now: var sequence = PRActionSequence(moveDown, moveUp); If you were to play this action against an object now, you will see the object first moves down and then, when that animation is done, it moves back up.  Great!  So we have one bounce, but now we need to repeat it forever so we can have a completed bouncing animation.  For this, we need another container action, a repeater.  We can create one that will repeat our sequence action an unlimited number of times, like this: var bounceAnim = PRActionRepeatForever(sequence); And there we have it!  Our completed custom bouncing compound action.  Let's play it: PRActionPlay(self, bounceAnim); You will now find your object happily bouncing up and down!  Container actions are extremely useful, especially sequence actions.  You can use them to create simple pre-scripted paths that an object travels, like the above bounce animation, or more complex ones like having a game character navigate a dangerous environment by running, jumping, rolling and climbing his way through it. There is one more container type of action to you should know: group actions.  A group action is similar to a sequence action except that instead of running the contained actions one at a time, the group action runs them all at the same time.  Let’s look at another example.  Let's say that we want to program a simple sentry that patrols in a rectangular pattern and rotates 90 degrees every second while patrolling.  That's 2 actions grouped together: one for the patrol pattern, and one for rotating, running at the same time, but independently.  So, let's create the patrol route first: var patrolPath = PRActionSequence(PRActionMoveXBy(300, PRActionEaseIdSinusoidalInOut, 2),PRActionMoveYBy(300, PRActionEaseIdSinusoidalInOut, 2),PRActionMoveXBy(-300, PRActionEaseIdSinusoidalInOut, 2),PRActionMoveYBy(-300, PRActionEaseIdSinusoidalInOut, 2),); Ok, we now have a sequence action that will move an object 300 pixels to the right, then 300 down, then 300 left, and finally 300 up.   Each leg will take 2 seconds to perform.  Now let's create an action that will perform a 90 degree rotation, and then wait 1 second: var rotate = PRActionSequence(PRActionRotateBy(-90, PRActionEaseIdExponentialInOut, 0.5),PRActionWait(1)); Now, let's create a group action that will play these actions simultaneously and repeatedly: var group = PRActionGroup(PRActionRepeatForever(patrolPath),PRActionRepeatForever(rotate),); And finally, make our sentry object play the action: PRActionPlay(simpleSentry, group); You'll notice that the sentry will move along the rectangular path, and rotate 90 degrees every second.  What's important here is that each action in the group will begin simultaneously when the group action is played, but they are independent of each other when playing.  In other words, one action does not wait for the other to finish before repeating it's own action.  In this grouped action, the patrol path action takes 8 seconds to complete each cycle while the rotate action only takes 1.5 seconds, including the 1 second wait.  If these two actions, for example, did not repeat, the total duration of the group animation would be 8 seconds and the group action would end once the longest animation playing has stopped. One final important note about container actions is this: they can be nested together.  So you can create a sequence action that consists of multiple other sequence, group and repeater actions which they themselves can contain other groups, sequences and repeaters, and so on.  This means that a single action can contain an entire tree structure of scripted actions that can play some very long and complex animations indeed.

PRActionScaleYTo

PRActionQShake(isHorz, travel, shakeCount, durationPerShakeSecs) Creates a compound action that, when played by an object, will shake the object back and forth either horizontally or vertically. Parameters: isHorz Set to true for horizontal shaking.  Set to false for vertical shaking. travel The distance that the shake travels. shakeCount The number of shakes to perform.  Specify a negative number here for infinite shaking. durationPerShakeSecs The time, in seconds, that it takes for the shake animation to travel from one extreme to the other and back. Return Value: The created action object.

Creating and Playing Actions Actions are the backbone of the PRAction extension.  The basic idea is that you will first create actions that your objects will play, and then you will instruct your objects to play those actions. For example, say that you want an object to move from it's current position in the room to the center of the room.  First you’ll create the action that will move the object to the desired location: var move = PRActionMoveTo(room_width/2, room_height/2, PRActionEaseIdLinear, 1); Then you'll tell the object to play that action: PRActionPlay(self, move); And that's it!  You will find that the above code moves the object to the center of the room, in a linear fashion and that the movement will take 1 second to perform. Now, what if you wanted that object to perform a 360 degree rotation on its way to the center of the room?  No problem, just add the following code to the above: var rotate = PRActionRotateBy(360, PRActionEaseIdLinear, 1); PRActionPlay(self, rotate); Yes, you can run multiple actions on any given object and they will all play without interfering with each other.  When the actions are done playing, they will stop themselves automatically. If you need an action to move slower or faster, increase or decrease the duration of the action when you create it: var rotateFaster = PRActionRotateBy(360, PRActionEaseIdLinear, 0.5); You may want to animate an action using a more interesting motion than a simple, even, linear type of motion.  Do so by specifying a different ease id for the action: var moveInterestingly = PRActionMoveTo(room_width/2, room_height/2, PRActionEaseIdCubicInOut, 1); There are lots of of different ease id's built into PRAction to use.  Please see the list of available ease id constants in the CONSTANTS tab above. Another key point to understand is that actions are reusable.  So, depending on what you need those actions for, you can certainly create an action once at game launch and play that action over and over on multiple objects throughout the life of your game.  Thus, you can do the following: PRActionPlay(object1, rotate); PRActionPlay(object2, rotate); PRActionPlay(object3, rotate); There are many more standard actions available in the PRAction extension that will animate your objects in various ways than simply moving them across the screen and rotating them.  There are actions to scale objects, fade them, hide and show them, change their animation speed, their depth and lots more. But that's just the beginning!  You will start to see the real power of PRAction when creating more complex animations by combining actions together using sequences and groups, and integrating repeating actions and waiting actions.  Please read the next document to start delving into compound actions.  You'll be creating cut-scenes, and much, much more in no time flat! Also, please see a list of all available action creation functions in the FUNCTIONS tab above.

PRActionSequenceArr

PRActionQPopOut(sizeUpTo, easeId, durationSecs) Creates a compound action that, when played by an object, will make the object appear to "pop” out of existence.  The object will first scale up from it's current size to sizeToMax and then quickly scale down to 0. Parameters: sizeUpTo The size that the object will grow to in the first half of the animation. easeId The ease id indicating which easing function to use for this animation. durationSecs The time it takes, in seconds, for the entire pop animation to play. Return Value: The created action object.

Getting Started Before you can make a GameMaker Studio object run actions, you'll need to make that object conform to using the PRAction engine.  Doing this requires the following three simple steps:      •Put a PRActionInit(); in the object's Create event.     •Put a PRActionUpdate(); in the object's Step event.      •Put a PRActionDestroy(); in the object's Destroy event. Once that is done, the object is ready to work with the PRAction extension. You may find it more convenient to create a top level object with these events and commands and then assign it as the parent object to each of the game objects that you want to conform to PRAction.  Whichever method you decide to use is fine. You are now ready to start creating and playing actions.  Please read the next document to begin.

PRActionSequence

Getting Started To make an object in your project conform to PRState, you must do the following:      • Put a PRStateInit(); in its Create event.     • Put a PRStateUpdate(); in its Step event.     • Put a PRStateDestroy(); in its Destroy event. You may find it more convenient to create a top level object with these events and commands and then assign it as the parent object to each of the game objects that you want to conform to PRState.  Whichever method you decide to use is fine. Adding States to your ObjectOnce you have an object that conforms to PRState, you can begin to add states to that object.  For example, in the Create event, after PRStateInit();, you may want to add the following states:    PRStateAdd(self, “Idle”, characterIdleState);   PRStateAdd(self, “Run”, characterRunState);    PRStateAdd(self, “Jump”, characterJumpState); The above code adds 3 states to the current object with the names “Idle”, “Run” and “Jump” and assigns the given script names to those states.  Then for each state you’ve added, you must create those script objects in your project with the same names.  In the above example, the script named characterIdleState will be responsible for handling the object’s Idle state, and the script named characterRunState will handle the object’s Run state and finally the script named characterJumpState will handle the object’s Jump action. Setting an Object’s StateBy default, an object that you have just added one or more states to has no “current” state, and will thus not respond via your state scripts.  Therefore, in your object’s Create event, you may want to set the object’s first state like so:    PRStateSet(self, “Idle”); The above code sets the current object’s current state to Idle.  This means that the object’s state scripts will begin to execute at the appropriate times.  You need not set the object’s initial state in its Create event, you can set it later on in your game if it makes more sense for that object. Implementing a State ScriptEach of the scripts that you've designated as a state script needs to receive 1 argument.  The PRState engine will call those scripts automatically at the appropriate times, passing them a “mode” argument.  Therefore at the top of each of your state scripts you will need a line similar to the following:    var mode = argument0; “mode” will be set to one of the following values each time your scripts are called: PRStateModeInit, PRStateModeUpdate and PRStateModeEnd.  In the body of your scripts, you will implement code to react to the given mode.  Responding to each of the modes is optional, so implement only the ones you need.  Each one is described below. When "mode" is equal to PRStateModeInit, this means that the state of your object has just changed and you are now given the opportunity to run some initialization code for the current state.  Continuing with the previous example, you might write something similar to the following in the characterIdleState script, right below the var mode = argument0; line:    // In characterIdleState script.   if mode == PRStateModeInit {      sprite_index = sprHeroStanding; // Set the object’s sprite to the hero’s awesome standing pose.      audio_play_sound(audWhistleTune, 7, true); // Our hero will begin whistling a tune while standing around waiting.      return;   } The above code means that upon entering the object’s Idle state, we set the hero’s current sprite to the appropriate standing/idle sprite image.  We also have the hero start a whistling ditty while he’s waiting for player input.  We issue a return statement so that the rest of the script isn’t executed, since we only want to cover the PRStateModeInit here. When the "mode" argument is equal to PRStateModeEnd, this means that the current state is about the end and a new state will begin shortly.  In this mode, you now have the opportunity to perform some cleanup or de-initialization routines.  Continuing with our previous example, you might write something like this:    // Still in characterIdleState script, after the previous code above.   if mode == PRStateModeEnd {      audio_stop_sound(audWhistleTune);  // Hero will no longer be standing idle, so he stops whistling.      return;   } The above code will run the moment right before an object’s state switches to another state, so we make sure that the hero isn’t whistling his lovely waiting-around tune because he won’t be idle anymore. When the "mode" argument is equal to PRStateModeUpdate, this means that your object needs to respond to the current frame update (the Step event.)  Your object’s current state script will be called with this mode once for each Step event, so you will likely code the bulk of your object’s state behaviour here.  Continuing with our idle state example, you might code something like this:    // No need for an IF statement here since there is only 1 mode left not handled yet.   // Nothing to do while the hero is idling except to monitor the player’s input, and make the hero run if input detected.   if keyboard_check(vk_left) or keyboard_check(vk_right) {      PRStateSet(self, “Run”);  // Left/right pressed! Switch to Run state which will handle the hero’s running action.      return;   }   if keyboard_check(vk_space) {      PRStateSet(self, “Jump”);  // Action pressed! Switch to Jump state which will handle the hero’s jumping action.      return;   } The above code will switch the object’s current state to either Run or Jump depending on which keys the player has pressed. This was a simple example of implementing a state script.  Your code that handles the PRStateModeUpdate mode will likely be much longer for the more complex states that your object might have.  The point here is to show that using states will segregate your object’s behaviour into sensible blocks of code that are called by PRState and handled by your scripts.  If you find that your Run state is still too complicated and long winded, for example, the you might consider breaking it down further by specifying “RunLeft” and “RunRight” states to split the code up ever further. Current and Previous StatesYou may find that, during your state scripts, or elsewhere in your project, you might need to know what the current state is for a given object, or what the object’s previous state was.  You can find this out easily using the following two functions calls:    var currentState = PRStateCurrent(self); // May return “Run”, for example.   var previousState = PRStatePrevious(self);  // May return “Idle”, for example. The above code will return strings with the names of the current and previous states. Restricting States From Other StatesFor objects with particularly complex states (or just to add code readability) you may want to declare that a state can only be set if the state being switched from is among a set of valid states.  For example, you may want your soldier object to fire his weapon only if he is standing or crouching, but not when he is jumping or climbing.  To do this, list the valid states to switch from in an array in the PRStateAdd() function: PRStateAdd(self, “Stand”, soldierStandState, [“Crouch”, “Jump”]); // Only allow Stand state from Crouch and Jump states.PRStateAdd(self, “Crouch”, soldierCrouchState, [“Stand”]);  // Only allow Crouch state from Stand state. PRStateAdd(self, “Climb”, soldierClimbState, [“Stand”]);  // Only allow Climb state from Stand state.PRStateAdd(self, “Jump”, soldierJumpState, [“Stand”]);  // Only allow Jump state from Stand state.PRStateAdd(self, “Shoot”, soldierShootState, [“Stand”, “Crouch”]]);  // Only allow Shoot from Stand & Crouch states. With the above states added to an object, issuing the following command would yield nothing: // Assuming the current state is “Climb”PRStateSet(self, “Shoot”);  // Nothing happens. Restricting states is a great way to prevent some really bizarre situations from occurring.  It also helps visualize an object’s abilities and state paths, which is a great help when coding your state scripts. Debug VerbosityIf you are having some trouble figuring out why and how states are being called for a given object when they shouldn’t be, it may help to turn on debug verbosity using PRStateSetVerbose(true).  Doing this within the context of a given object will write state changes and instance information to the output window to help track down bugs.

PRActionQPopIn(sizeToMax, sizeToNormal, easeId, durationSecs) Creates a compound action that, when played by an object, will make the object appear to "pop" into existence.  The action will first set the scale X/Y of the object to 0 before beginning the pop animation. Parameters: sizeToMax The max size that the object will grow to in the first half of the animation. sizeToNormal The size that the object will settle at when it retracts from the initial pop. easeId The ease id indicating which easing function to use for this animation. durationSecs The time it takes, in seconds, for the entire pop animation to play. Return Value: The created action object.

PRActionRepeatForever

PRActionQJumpBounce(travel, travelAngle, bounceLoss, repeatCount, easeUpId, easeDownId, jumpDurationSecs, delaySecs) Creates a compound action that, when played by an object, will cause the object to travel away from it's starting point, up along the given travelAngle until the distance given in travel is reached, and then falls back down to it's starting point, where it will then bounce again lower and lower repeatedly until settles, as though by gravity.  Each primary bounce duration will be jumpDurationSecs seconds, and does not include the time it takes for the object to settle back down via the smaller bounces. Parameters: travel The distance that the bounce travels. travelAngle The angle that the bounce occurs, with 90 being straight up. bounceLoss How much of the bounce energy is lost after each bounce.  Must be greater than 0 and less than or equal to 1. repeatCount The number of times the entire bounce animation repeats.  Specify a negative number here for infinite bouncing. easeUpId The ease id indicating which easing function to use for the first half of the bounce. easeDownId The ease id indicating which easing function to use for the second half of the bounce. jumpDurationSecs The time, in seconds, that it takes for each bounce to occur. delaySecs The time, in seconds, that it waits before starting the next bounce repeat. Return Value: The created action object.

PRActionRepeat

PRActionPlayCount

PRActionQHeartbeat(sizeBy, repeatCount, easeId, durationPerBeatSecs, delaySecs) Creates a compound action that, when played by an object, will make it seem like the object is pulsating like a heartbeat by playing with the object's scaling. Parameters: sizeBy The relative scaling that occurs for each heartbeat. repeatCount The number of heartbeats to do.  Specify a negative number here for infinite heartbeats. easeId The ease id indicating which easing function to use for this animation. durationPerBeatSecs The time, in seconds, that it takes for each heartbeat to occur. delaySecs The time, in seconds, that it waits in between heartbeats. Return Value: The created action object.

PRActionGroup

PRActionSetData2

Container Action Functions

PRActionQFloat(hTravel, hDurationSecs, vTravel, vDurationSecs) Creates a compound action that, when played by an object, will make it appear that the object is floating endlessly. Parameters: hTravel The horizontal distance that the object travels during floating. hDurationSecs The duration that it takes for the object to travel from one end of it's horizontal travel distance to the other. vTravel The vertical distance that the object travels during floating. vDurationSecs The duration that it takes for the object to travel from one end of it's vertical travel distance to the other. Return Value: The created action object.

PRActionSetData1

PRActionWait

PRActionSetEase

PRActionBlendTo

Creating Compound Actions

PRActionBlendBy

Creating and Playing Actions

PRActionAlphaTo

PRActionQFlipXY(xFlipDurationSecs, yFlipDurationSecs, repeatCount, easeId) Creates a compound action that, when played by an object, will make it appear that the object is flipping end-over-end in the X and Y directions. Parameters: xFlipDurationSecs The time, in seconds, that it takes for one full flip along the x-axis.  Specify 0 here for no flipping along the x-axis. yFlipDurationSecs The time, in seconds, that it takes for one full flip along the y-axis.  Specify 0 here for no flipping along the y-axis. repeatCount The number of flips to make.  Specify a negative number here for infinite flipping. easeId The ease id indicating which easing function to use for this animation. Return Value: The created action object.

PRActionQBreathe(sizeBy, repeatCount, easeId, durationPerBreathSecs, delaySecs) Creates a compound action that, when played by an object, will make it seem like the object is "breathing" by altering the X/Y scaling over time. Parameters: sizeBy The relative scaling that occurs for each breath. repeatCount The number of breaths to take.  Specify a negative number here for infinite breathing. easeId The ease id indicating which easing function to use for this animation. durationPerBreathSecs The time, in seconds, that it takes for each breath to occur. delaySecs The time, in seconds, that it waits in between each breath. Return Value: The created action object.

PRActionUnhide

PRActionQBounce(travel, travelAngle, repeatCount, easeUpId, easeDownId, jumpDurationSecs) Creates a compound action that, when played by an object, will bounce the object from it's starting point, up along the given travelAngle until the distance given in travel is reached, and then falls back down to it's starting point.  Each bounce duration will be jumpDurationSecs seconds. Parameters: travel The distance that the bounce travels. travelAngle The angle that the bounce occurs, with 90 being straight up. repeatCount The number of bounces.  Specify a negative number here for infinite bouncing. easeUpId The ease id indicating which easing function to use for the first half of the bounce. easeDownId The ease id indicating which easing function to use for the second half of the bounce. jumpDurationSecs The time, in seconds, that it takes for each bounce to occur. Return Value: The created action object.

PRActionStopSound

PRActionQBlendFlash(color1, color2, fade1DurationSecs, fade1DelaySecs, fade2DurationSecs, fade2DelaySecs, easeId) Creates a compound action that, when played by an object, will fade blend that object between 2 colors repeatedly using the given parameters.  The action will first set the object's image_blend instance variable to color1. Parameters: color1 The first color to fade from. color2 The second color to fade to. fade1DurationSecs The time, in seconds, that it takes to fade blend from color1 to color2. fade1DelaySecs The time, in seconds, that it waits after fading from color1 to color2. fade2DurationSecs The time, in seconds, that it takes to fade blend from color2 to color1. fade2DelaySecs The time, in seconds, that it waits after fading from color2 to color1. easeId The ease id indicating which easing function to use for this animation. Return Value: The created action object.

PRActionStopAllSounds

PRActionQAlphaFlash(startVisible, fadeOutDurationSecs, fadeOutDelaySecs, fadeInDurationSecs, fadeInDelaySecs, easeId) Creates a compound action that, when played by an object, will fade that object in and out repeatedly using the given parameters. Parameters: startVisible A boolean that indicates if the object should start out visible before fading out (true) or if it should start invisible and then fade in (false). fadeOutDurationSecs The time, in seconds, that it takes to fade out. fadeOutDelaySecs The time, in seconds, that it waits after fading out and before fading back in. fadeInDurationSecs The time, in seconds, that it takes to fade in. fadeInDelaySecs The time, in seconds, that it waits after fading in and before fading back out. easeId The ease id indicating which easing function to use for this animation. Return Value: The created action object.

PRActionStopAction

PRActionEaseSinusoidalOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Sinusoidal Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionSpriteIndex

PRActionEaseSinusoidalInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Sinusoidal In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionRunUserEvent

PRActionRunScript

PRActionEaseSinusoidalIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Sinusoidal In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionPlaySound

PRActionEaseQuinticOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quintic Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionPlayAction

PRActionEaseQuinticInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quintic In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionHide

ABOUT

PRActionEaseQuinticIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quintic In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionDepthTo

PRActionEaseQuarticOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quartic Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionDepthBy

PRActionEaseQuarticInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quartic In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionChangeLayer

HOW TO USE

PRActionEaseQuarticIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quartic In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

Instant Action Functions

FUNCTIONS

PRActionEaseQuadraticOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quadratic Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionQWobble

CONSTANTS

PRActionEaseQuadraticInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quadratic In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionQSlideFade

PRActionEaseQuadraticIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Quadratic In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionQShake

PRActionEaseLinear(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Linear easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconJoyGetVisible

PRActionQPopOut

PRActionEaseExponentialOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Exponential Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRActionQPopIn

PRActionEaseExponentialInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Exponential In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconJoySetVisible

PRVirconJoyIsDown(joyId) Returns true if the joystick is being pressed down and outside of the deadzone, if one is defined.  false, otherwise. Parameters:joyId The joystick ID. Return Value: true or false

PRActionQJumpBounce

PRVirconBtnGetVisible

PRVirconJoyGetYValue(joyId) Returns the y-value of the given joystick, which is a value between -1 and +1 and relates to how far from the center the joystick is positioned vertically.  Returns 0 if the joystick is centered vertically or if the joystick is within the deadzone, if one is defined.  If the joystick's y-invert is set to false, pressing down on the joystick will return negative values while pressing up will return positive ones.  If the joystick's y-invert is true, the reported values are reversed. Parameters:joyId The joystick ID. Return Value: A value between -1 and +1 indicating the joystick's position vertically.

PRVirconJoyGetTravelDistance(joyId) Returns the given joystick's travel distance in pixels.  i.e. How far the joystick can move. Parameters:joyId The joystick ID. Return Value: The travel distance size in pixels.

Constants The following is a list of constants defined in the PRState extension. PRStateModeInit Specifies the initialization mode of a state script implementation.  Supplied as argument0 when a state script is called.  Use as an indication that it is the proper moment to run your state initialization code. PRStateModeUpdate Specifies the frame update mode of a state script implementation.  Supplied as argument0 when a state script is called.  Use as an indication that it is the proper moment to run your core state code. PRStateModeEnd Specifies the clean-up/destruction mode of a state script implementation.  Supplied as argument0 when a state script is called.  Use as an indication that it is the proper moment to run your state clean-up/destruction code.

PRVirconBtnSetVisible

PRVirconJoyGetXValue(joyId) Returns the x-value of the given joystick, which is a value between -1 and +1 and relates to how far from the center the joystick is positioned horizontally.  Returns 0 if the joystick is centered horizontally or if the joystick is within the deadzone, if one is defined.  If the joystick is pressed left, negative values are returned.  If pressed right, positive values are returned. Parameters:joyId The joystick ID. Return Value: A value between -1 and +1 indicating the joystick's position horizontally.

PRVirconGetGUIHeight

PRVirconJoyGetTouchRadius(joyId) Returns the given joystick's touch radius size in pixels. Parameters:joyId The joystick ID. Return Value: The touch radius size in pixels, unmodified by the scale size of the joystick.

PRVirconJoySetNotches(joyId, distFromCenter, forSelected, spriteRight, spriteTopRight, spriteTop, spriteTopLeft, spriteLeft, spriteBottomLeft, spriteBottom, spriteBottomRight) Sets the given joystick's notch sprites.  The notches are drawn at each of the 8 cardinal points a set distance from the center of the joystick nub.  Set the sprite parameters to noone if you don’t want a notch sprite to draw at that point.  Call this function with forSelected = true to set the notch sprites to draw when the joystick is pressed in their direction.  Call this function with forSelected = false to set the notch sprites to draw when the joystick is NOT pressed in their direction.  If no sprites are assigned when forSelected = true, then the sprites assigned when forSelected = false will be drawn instead. Parameters:joyId The joystick ID. distFromCenter The distance (in pixels) from the center of the joystick nub to draw the notches. forSelected If true, assigns the given sprites to the joystick notches for when the joystick is pressed in their direction.  If false, the given sprites are assigned to the notches when the joystick is NOT pressed in their direction. spriteRight The notch sprite to use for the right direction. spriteTopRight The notch sprite to use for the top-right direction. spriteTop The notch sprite to use for the top direction. spriteTopLeft The notch sprite to use for the top-left direction. spriteLeft The notch sprite to use for the left direction. spriteBottomLeft The notch sprite to use for the bottom-left direction. spriteBottom The notch sprite to use for the bottom direction. spriteBottomRight The notch sprite to use for the bottom-right direction. Return Value: n/a

PRVirconJoySetYInvert(joyId, invert) Sets the given joystick's y-inversion.  If invert is set to false (the default behaviour), pressing the joystick up will return positive values while pressing the joystick down will return negaive values.  Setting invert to true will reverse this logic. Parameters:joyId The joystick ID. invert true or false, indicating whether the returned joystick values are inverted or not. Return Value: n/a

PRVirconJoyGetVisible(joyId) Returns true or false indicating if the given joystick is set to be visible or not. Parameters:joyId The joystick ID. Return Value: true or false.

PRActionEaseExponentialIn(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Exponential In easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

Joystick Appearance

PRVirconJoyGetSnapsToCenter(joyId) Returns true or false indicating whether or not the given joystick automatically snaps to center when the player lets it go. Parameters:joyId The joystick ID. Return Value: true or false

PRVirconJoySetLabel

PRVirconJoySetLabel(joyId, sprite, xOffsetX, yOffset, scale, rotation) Sets the given joystick's label sprite. Parameters:joyId The joystick ID. sprite The sprite to use for the joystick's label. xOffset The x-offset of the label sprite from the center of the joystick's nub. yOffset The y-offset of the label sprite from the center of the joystick's nub. scale The scale size to apply to the label sprite with 1 being normal size. rotation The angle at which to draw the label sprite. Return Value: n/a

PRActionQHeartbeat

PRActionEaseCubicOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Cubic Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconSetGUISize(guiWidth, guiHeight) Changes the size of the GUI resolution that PRVircon uses to draw itself.  Will immediately adjust the positions of the UI elements to compensate for the new resolution. Parameters: guiWidthThe desired width of the GUI. guiHeightThe desired height of the GUI. Return Value: n/a

PRVirconJoySetTravelDistance(joyId, travelDistance) Sets the given joystick's travel distance in pixels.  This value determines how far the joystick nub can be dragged by the player when it is moved.  It is not affected by the joystick's scale size. Parameters:joyId The joystick ID. travelDistance The travel distance in pixels. Return Value: n/a

PRVirconJoySetVisible(joyId, visible) Sets whether or not the given joystick should be visible.  When not visible, the joystick will receive no input from the player. Parameters:joyId The joystick ID. visible true if joystick should be visible.  false if hidden. Return Value: n/a

PRActionQFloat

PRActionEaseCubicInOut(currentTime, startValue, deltaValue, duration, data1) While any kind of animation can be created using the standard complement of PRAction functions without needing to deal directly with the easing functions, they have been made available for use and experimentation, should it be desired. This function will return a value that lies within a range of numbers for the given completion percentage, using the Cubic In/Out easing equation.  The completion percentage is determined by currentTime over duration. Parameters: currentTime A number representing the current point in time.  Can be in any unit of measure.  Must be between 0 and duration. startValue The starting value of the number range in which the returned value will be calculated. deltaValue The ending value of the number range, less the startValue, in which the returned value will be calculated. duration The total duration of the animation.  Must be in the same unit of measure as currentTime. data1 Not used. Return Value: The calculated result.

PRVirconJoyGetScale

PRVirconJoyGetName(joyId) Returns the given joystick's name. Parameters:joyId The joystick ID. Return Value: The name of the joystick.

PRVirconJoyAdd

PRVirconJoySetBlend(joyId, nubBlendColor, labelBlendColor, outlineBlendColor, notchBlendColor) Sets the blend color to use for the given joystick's nub, label, outline and notch sprites. Parameters:joyId The joystick ID. nubBlendColor The blend color to use for the joystick's nub sprite. labelBlendColor The blend color to use for the joystick's label sprite. outlineBlendColor The blend color to use for the joystick's outline sprite. notchBlendColor The blend color to use for the joystick's notch sprites. Return Value: n/a

DEMO REEL

Prismatic Realms, Inc. is an independent software developer based in Whitby, Ontario, Canada. Our primary focus is the passionate development of cross-platform computer games that pay homage to the 8-, 16- and 32-bit 2D gaming era. We fell in love with early computer and video game systems such as the Commodore 64, Amiga, Nintendo Entertainment System, Super NES, Sega Genesis and PlayStation. Our mission is to channel this tempest of nostalgic energy into creating the kinds of games that we grew up with, maybe add a little modern flair, and then share them with everyone that feels the same way about retro-gaming. In addition we provide a variety of services including game graphics, audio, pro- gramming and HTML5 web development.

Information about Memroid coming soon.