TweenGMS Pro v1.20
Script Reference

// Tween x position to mouse_x over 30 steps
TweenFire(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", x, mouse_x);

// Tween instance's scale back and forth from 0 to 1 over 2.0 seconds
TweenFire(id, EaseInOutQuad, TWEEN_MODE_PATROL, true, 0.0, 2.0, "image_xscale", 0, 1, "image_yscale", 0, 1);

// Tween x position to mouse_x over 30 steps
TweenFireTo(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", mouse_x);

// Double instances image scale over 1.0 second
TweenFireTo(id, EaseInOutQuad, TWEEN_MODE_PATROL, true, 0.0, 1.0, "image_scale", 2.0);

// Tween x position from mouse_x over 30 steps
TweenFireFrom(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", mouse_x);

// Tween image scale from 2 to default value over 1.0 second
TweenFireFrom(id, EaseInOutQuad, TWEEN_MODE_PATROL, true, 0.0, 1.0, "image_scale", 2.0);

// Chain various tweens to fire one after another
tween1 = TweenFire(id, EaseOutBounce, 0, true, 0, 1.0, "y", -100, y);
tween2 = TweenMore(tween1, id, EaseInOutQuad, 0, true, 0, 0.5, "image_yscale", 1, 0.25);
tween3 = TweenMore(tween1, id, EaseInOutSine, 0, true, 0, 1.0, "image_angle", 0, 360);
tween4 = TweenMore(tween3, id, EaseInOutQuad, 0, true, 0, 2.0, "image_xscale", 1, 0.5);

// Create a defined tween, easing x position to mouse_x over 30 steps
tween = TweenCreate(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", x, mouse_x);
TweenPlay(tween);

// Create an undefined tween and override it with TweenPlay()
tweenY = TweenCreate(id);
TweenPlay(tweenY, EaseLinear, TWEEN_MODE_ONCE, false, 0, 30, "y", y, mouse_y); 

// Tween x position to mouse_x over 30 steps
tweenX = TweenCreate(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", x, mouse_x);
TweenPlay(tweenX);

// Create an undefined tween and override it with TweenPlay()
tweenY = TweenCreate(id);
TweenPlay(tweenY, EaseLinear, TWEEN_MODE_ONCE, false, 0, 30, "y", y, mouse_y);

// This would optionally start both tweens at the same time by using the "Tween Selection" scripts
// But note that all tweens should be previously defined.
TweenPlay(Tweens(tweenX, tweenY)); 

// Tween x position to mouse_x over 30 steps after a 60 step delay
tweenX = TweenCreate(id, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 0, "x", x, mouse_x);
TweenPlayDelay(tweenX, 60);

// Create an undefined tween, then define it with TweenDefine() before playing
tween = TweenCreate(id);
TweenDefine(tween, EaseOutQuad, TWEEN_MODE_ONCE, false, 0, 30, "x", x, mouse_x);
TweenPlay(tween);

// Display a message after 1 second
ts = TweenScript(id, true, 1.0, ShowMessage, "Hello, World!");

// Schedule another script to be fired 2 seconds after first one finishes
ts = TweenMoreScript(ts, id, true, 2.0, ShowMessage, "Goodbye, World!");

// Fire a tween after showing second message
t = TweenMore(ts, id, EaseInQuad, 0, true, 0.0, 1.0, "image_scale", 1.0, 0.0); 

// Display a message after 1 second
ts = TweenScript(id, true, 1.0, ShowMessage, "Hello, World!");

// Schedule another script to be fired 2 seconds after first one finishes
ts = TweenMoreScript(ts, id, true, 2.0, ShowMessage, "Goodbye, World!");

// Fire a tween after showing second message
t = TweenMore(ts, id, EaseInQuad, 0, true, 0.0, 1.0, "image_scale", 1.0, 0.0);

// Tween x position to mouse_x over 30 steps after a 60 step delay
TweenEasyMove(x, y, mouse_x, mouse_y, 60, 30, EaseInOutQuad);

// Tween image angle from 0 to 360 over 30 steps
TweenEasyRotate(0, 360, 0, 30, EaseInOutQuad);

// Tween image x/y scale from 1.0 to 2.0 over 30 steps
TweenEasyScale(1.0, 1.0, 2.0, 2.0, 0, 30, EaseInOutQuad);

// Tween instance's direction from 0 to 360 over 30 steps
TweenEasyTurn(0, 360, 0, 30, EaseInOutQuad);

// Tween instance's image alpha from 0.0 to 1.0 over 30 steps
TweenEasyFade(0.0, 1.0, 0, 30, EaseInOutQuad);

// Tween instance's image blend colour from white to red over 30 steps
TweenEasyBlend(c_white, c_red, 0, 30, EaseInOutQuad);

// Tween instance's image index from first to last frame over 30 steps
TweenEasyImage(0, image_number-1, 0, 30, EaseInOutQuad);

// Tween instance's speed from 0 to 10 over 30 steps
TweenEasySpeed(0, 10, 0, 30, EaseInOutQuad);

// Tween instance's hspeed/vspeed from 0 to 10 over 30 steps
TweenEasySpeedHV(0, 0, 10, 10, 0, 30, EaseInOutQuad);

// Tween instance's position over 30 steps
TweenEasyMove(x, y, mouse_x, mouse_y, 0, 30, EaseInOutQuad);

// Change default timing method to true (use seconds)
TweenEasyUseDelta(true);

// Tween instance's angle over 3.5 seconds
TweenEasyMoveRotate(0, 360, 0, 3.5, EaseInQuad);

// Pause all indicated tweens
TweenPause(Tweens(tweenOne, tweenTwo, tweenDerp));

// Pause all tweens
TweenPause(TweensAll());

// Resume all tweens with alternate "all" keyword
TweenResume(all);

// Pause all tweens associated with group 2
TweenPause(TweensGroup(2));

// Pause all tweens associated with a target instance id
TweenPause(TweensTarget(id));

// Resume all tweens associated with a target's object index
TweenResume(TweensTarget(obj_Player));

// Set Tweens*() scripts to include deactivated targets
TweensIncludeDeactivated(true);

// Pause all tweens, even tweens associated with deactivated instances 
TweenPause(all);

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", x, mouse_x);

// Pause the tween
TweenPause(tween);

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", x, mouse_x);

// Pause the tween
TweenPause(tween);

// Resume the tween
TweenResume(tween);

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", x, mouse_x);

// Stop the tween
TweenStop(tween);

// Fire tween
tween = TweenFire(id, EaseLinear, TWEEN_MODE_PATROL, true, 0, 1, "x", x, mouse_x);

// Reverse the tween
TweenReverse(tween);

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", x, mouse_x);

// Finish tween and call "finish" event
TweenFinish(tween, true);

// Fire tween with a 3.0 second delay
tween = TweenFire(id, EaseLinear, 0, true, 3.0, 1, "x", x, mouse_x);

// Finish the tweens delay and start playing... call delay's "finish" event
TweenFinishDelay(tween, true);

// Fire tween from x/y to mouse_x/mouse_y
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", x, mouse_x, "y", y, mouse_y);

// Pause the tween if it exists
if (TweenExists(tween))
{
    TweenPause(tween);
}

// Fire tween with a 3.0 second delay
tween = TweenFire(id, EaseLinear, 0, true, 3.0, 1.0, "x", x, mouse_x);

// Pause the tween if it is playing or delayed
if (TweenIsActive(tween))
{
    TweenPause(tween);
}

// Fire tween with a 3.0 second delay
tween = TweenFire(id, EaseLinear, 0, true, 3.0, 1.0, "x", x, mouse_x);

// Pause the tween if it is playing
if (TweenIsPlaying(tween))
{
    TweenPause(tween);
}

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "x", x, mouse_x);

// Pause tween
TweenPause(tween);

// Resume the tween if it is paused
if (TweenIsPaused(tween))
{
    TweenResume(tween);
}

// Fire tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "x", x, mouse_x);

// Pause tween
TweenStop(tween);

// Show message if tween is stopped
if (TweenIsStopped(tween))
{
    show_message("Tween Stopped!");
}

	Supported Data Labels:
        "group"         -- Group which tween belongs to
        "time"          -- Current time of tween in steps or seconds
        "time_amount"   -- Sets the tween's time by a relative amount between 0.0 and 1.0 
        "time_scale"    -- How fast a tween updates : Default = 1.0
        "duration"      -- How long a tween takes to fully animate in steps or seconds
        "ease"          -- The easing algorithm used by the tween
        "mode"          -- The play mode used by the tween (ONCE, BOUNCE, PATROL, LOOP)
        "target"        -- Target instance associated with tween
        "delta"         -- Toggle timing between seconds(true) and steps(false)
        "delay"         -- Current timer of active delay
        "delay_start"   -- The starting duration for a delay timer
        "start"         -- Start value of the property or properties
        "destination"   -- Destination value of the property or properties
        "property"      -- Property or properties effected by the tween

// Fire a tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "x", x, mouse_x);

// Track tween's start and destination values
start = TweenGet(tween, "start");
destination = TweenGet(tween, "destination");

    Supported Data Labels:
        "group"         -- Group which tween belongs to
        "time"          -- Current time of tween in steps or seconds
        "time_amount"   -- Sets the tween's time by a relative amount between 0.0 and 1.0 
        "time_scale"    -- How fast a tween updates : Default = 1.0
        "duration"      -- How long a tween takes to fully animate in steps or seconds
        "ease"          -- The easing algorithm used by the tween
        "mode"          -- The play mode used by the tween (ONCE, BOUNCE, PATROL, LOOP)
        "target"        -- Target instance associated with tween
        "delta"         -- Toggle timing between seconds(true) and steps(false)
        "delay"         -- Current timer of active delay
        "delay_start"   -- The starting duration for a delay timer
        "start"         -- Start value of the property or properties
        "destination"   -- Destination value of the property or properties
        "property"      -- Property or properties effected by the tween
        
        e.g.
            tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", 0, 100);
            TweenSet(tween, "duration", 2.5);
            
    // The following labels can update multiple properties by supplying
    // values in the same order the properties were first assigned:
        
        "start"
        "destination"
        "property"
        
        e.g.
            tween = Tween(id, EaseLinear, 0, true, 0, 1, "x", 0, 100, "y", 0, 100); // multi-property tween (x/y)
            TweenSet(tween, "start", mouse_x, mouse_y); // update to x/y mouse coordinates
           
    // The keyword [undefined] can be used to leave a property value unchanged
        e.g.
            TweenSet(tween, "start", undefined, mouse_y); // update "y" but leave "x" unchanged

// Fire a new tween
tween = TweenFire(id, EaseLinear, 0, true, 0, 1, "x", 0, 100);

// Change tween's duration to 2.5 seconds
TweenSet(tween, "duration", 2.5);

// Create an undefined tween
tween = TweenCreate(id);

// Manually destroy the tween
TweenDestroy(tween);

// Manually destroy the tween without checking if it is valid. No error will occur. BE CAREFUL!
TweenDestroySafe(tween);

// Create an undefined tween
tween = TweenCreate(id);

// Force tween to auto-destroy when it is finished playing
TweenDestroyWhenDone(tween, true);

// Set "tween" variable to a null tween id
tween = TweenNull();

// No error will be occur if tween is null
TweenPause(tween);

// Check if the tween exists
if (TweenExists(tween))
{
    // ... this won't execute if tween is null
}

// Set the default group for new tweens to 2
TweenSet(TweenDefault(), "group", 2);

// New tween will belong to group 2
TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "x", x, mouse_x);

// Find eased value between 0 and 100 at amount of 0.75 with EaseInOutQuad
value = Ease(0, 100, 0.75, EaseInOutQuad);

Steps a tween forward or backward by a given amount.
The direction can be a decimal (floating point) value.
        
Using 1.0 or -1.0 will step a tween 1 step in the indicated direction.
Lesser values, such as 0.5, will step the tween half a step foward.
Greater values, such as 2.0, will step a tween 2 steps forward.

// Step a tween forward at half speed
TweenStep(tween1, 0.5);

// Step another tween backward at double speed
TweenStep(tween2, -2.0);

Allows for the tweening of a path resource.

// Fire a tween using a GameMaker path
TweenPath(id, EaseLinear, TWEEN_MODE_ONCE, true, 0.0, 1.0, path1, true);

// Get value of a tween using it's current state
value = TweenCalc(tween);

// Create defined tween with a duration of 3.0 seconds
tween = TweenCreate(id, EaseInOutQuint, 0, true, 0.0, 3.0, TPNull(), x, mouse_x);
        
// Calculate value of tween at 1.5 seconds
x = TweenCalcTime(tween, 1.5);

// Create defined tween with a duration of 3.0 seconds
tween = TweenCreate(id, EaseInOutQuint, 0, true, 0.0, 3.0, TPNull(), x, mouse_x);
        
// Calculate value of tween at 25% through time
x = TweenCalcAmount(tween, 0.25);

// Tween a null property from 0 to 100
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, TPNull(), 0, 100);
        
// Manually calculate and store the tween's current value
myValue = TweenCalc(tween);

/// extColourBlend Setter Function
function extColourBlend(_value, _data, _target)
{
    _target.colour_blend = merge_colour(_data[0], _data[1], _value);
}

// Create a defined tween with an extended property
tween = TweenCreate(id, EaseInQuad, 0, true, 0.0, 3.0, TPExt(extColourBlend, c_red, c_blue), 0, 1);

// Create a defined tween with an extended property
tween = TweenCreate(id, EaseInQuad, 0, true, 0.0, 3.0, TPUser(0, c_red, c_blue), 0, 1);
        
/// User Event 0
var _value = TWEEN_USER_VALUE;
var _data = TWEEN_USER_DATA;
my_colour = merge_colour(_data[0], _data[1], _value);

// Tween image_scale for self and obj_Dude
TweenFire(self, EaseInQuad, 0, true, 0, 1, "image_scale", 1, 2, TPInst(obj_Dude, "image_scale"), 1, 4);

// Tween "value" for self and for some_struct
TweenFire(self, EaseInQuad, 0, true, 0, 1, "value", 0, 50, TPStruct(some_struct, "value"), 0, 100);

// Create a 1d array and pass it as the tween property with TPArray().
myArray[0] = 0;
tween = TweenFire(id, EaseInQuad, 0, true, 0.0, 3.0, TPArray(myArray, 0), 0, 100);
        
// Get value from tweened array index
value = myArray[0];

// Create a list and pass it as the tween property with TPList().
myList = ds_list_create();
myList[| 0] = 0;
tween = TweenFire(id, EaseInQuad, 0, true, 0.0, 3.0, TPList(myList, 0), 0, 100);
        
// Get value from tweened array index
value = myList[| 0];

// Create a map and pass it as the tween property with TPMap().
myMap = ds_map_create();
myMap[? "key"] = 0;
tween = TweenFire(id, EaseInQuad, 0, true, 0.0, 3.0, TPMap(myList, "key"), 0, 100);
        
// Get value from tweened map key
value = myMap[? "key"];

// Create a grid and pass it as the tween property with TPGrid().
myGrid = ds_grid_create(10,10);
tween = TweenFire(id, EaseInQuad, 0, true, 0.0, 3.0, TPGrid(myGrid, 2, 4), 0, 100);
        
// Get value from tweened grid index
value = myGrid(# 2, 4);

// Fire a tween
tween = TweenFire(id, EaseInQuad, 1, true, 0.0, 1.0, "x", x, mouse_x);

// Have a function execute when tween finishes
TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Finished!");

// Add callback using a method from another object -- Use undefined target to retain method's existing "self" (obj_Player)
TweenAddCallback(tween, TWEEN_EV_CONTINUE, undefined, obj_Player.Jump);

// Omitting a target will also make it undefined and use the method's "self" environment, like the line above
TweenAddCallback(tween, TWEEN_EV_CONTINUE, , obj_Player.SayWahoo);

// Fire a tween
tween = TweenFire(id, EaseInQuad, 0, true, 0.0, 1.0, "x", x, mouse_x);

// Have a user event 5 execute when tween finishes
cb = TweenAddCallbackUser(tween, TWEEN_EV_FINISH, id, 5);

// Set a null callback
cb = TweenCallbackNull();

// No error will occur when calling null callback
TweenCallbackInvalidate(cb);

// Add callback to a tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Invalidate (destroy) the callback if valid
if (TweenCallbackIsValid(cb))
{
    TweenCallbackInvalidate(cb);
}
else
{
    show_message("Callback already invalidated!");
}

// Add callback to a tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Check if a callback id is valid
if (TweenCallbackIsValid(cb))
{
    show_message("Callback is valid!");
}
else
{
    show_message("Callback is not valid!");
}

// Add callback to a tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Temporarily disable the callback
TweenCallbackEnable(tween, false);

// Re-enable the disabled callback
TweenCallbackEnable(tween, true);

// Add callback to a tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Temporarily disable the callback
TweenCallbackEnable(tween, false);

// Show message if callback not enabled
if (TweenCallbackIsEnabled(cb) == false)
{
    show_message("Callback is disabled!");
}

// Fire a tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "y", y, mouse_y);

// Add callback to tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Invalidate all callbacks associated with tween event "finish"
TweenEventClear(tween, TWEEN_EV_FINISH);

// Fire a tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "y", y, mouse_y);

// Add callback to tween
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");

// Disable event callbacks associated with tween event "finish"
TweenEventEnable(tween, TWEEN_EV_FINISH, false);

// Fire a tween
tween = TweenFire(id, EaseLinear, 0, true, 0.0, 1.0, "y", y, mouse_y);

// Add callback to tween if event is enabled
if (TweenEventIsEnabled(tween, TWEEN_EV_FINISH))
{
    cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, "Hi!");
}

// Get the system's current time scale value
timeScale = TweenSystemGet("time_scale");

// Set the system's current time scale to 0.5 (half speed)
TweenSystemSet("time_scale", 0.5);

// Get number of tweens in system
tCountAll = TweenSystemCount();

// Get number of tweens playing 
tCountPlaying = TweenSystemCount("playing");

// Destroy tweens in persistent menu room
TweenSystemClearRoom(rm_Menu);

// Destroy tweens in all persistent rooms 
TweenSystemClearRoom(all);

// Immediately flush all destroyed tweens from system
TweenSystemFlushDestroyed();

// Activate the shared tweener controller object if deactivated
SharedTweenerActivate();

// Destroy the shared tweener controller object
SharedTweenerDestroy();

// Prepare "abc" property to be optmised with setter/getter functions
function SET_abc(_value, _target){ _target.abc = _value; }
function GET_abc(_target){ return _target.abc; }
TGMS_BuildProperty("abc", SET_abc, GET_abc);

// Prepare a property to be normalized for values between 0-1.
// _data[0] and _data[1] will hold the start/destination values.
// _value will hold a number between 0 and 1 based on the tween's progress.
function SET_colour(_value, _data, _target){ _target.colour = merge_colour(_data[0], _data[1], _value); }
function GET_colour(_target){ return _target.colour; }
TGMS_BuildPropertyNormalize("colour", SET_colour, GET_colour);
	
TweenFire(id, EaseInOutQuad, 0, true, 0, 1, "colour", c_white, c_blue);