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

// Tween instance's image alpha back and forth from 0 to 1 over 2.0 seconds
TweenFire(id, image_alpha__, EaseInOutQuad, TWEEN_MODE_PATROL, true, 0.0, 2.0, 0, 1);

// Tween instance's image angle 360 degrees for 1 second after a 1.5 second delay
TweenFire(id, image_angle__, EaseInOutBack, TWEEN_MODE_ONCE, true, 1.5, 1.0, 0, 360);

// Tween instance's position to mouse position using extended property setter
TweenFire(id, ext_xy__, EaseOutElastic, 0, true, 0.0, 1.0, 0, 1, x, mouse_x, y, mouse_y);

Returns: tween id

// Create undefined tween
tween_undef = TweenCreate(id);
// Create defined tween
tween_def = TweenCreate(id, x__, EaseOutQuart, TWEEN_MODE_BOUNCE, true, 1.0, 5.0, x, mouse_x);	

Returns: na

// Create undefined tween
tween1 = Tweencreate(id);
// Define and play tween
TweenPlay(tween1, x__, EaseInElastic, TWEEN_MODE_PATROL, true, 0.0, 2.5, x, mouse_x);

// Create a defined tween
tween2 = TweenCreate(id, y__, EaseOutQuad, TWEEN_MODE_PATROL, true, 0.0, 2.5, y, mouse_y);
// Play defined tween
TweenPlay(tween2);	

Returns: na

// Create a defined tween
tween2 = TweenCreate(id, y__, EaseOutQuad, TWEEN_MODE_PATROL, true, 0.0, 2.5, y, mouse_y);
// Play defined tween after delay of 5.0 seconds
TweenPlayDelay(tween2, 5.0);

Returns: null tween id

// Create tween
tween = TweenCreate(id);

// Manually destroy tween
TweenDestroy(tween);

Returns: null tween id

// Get previous tween stored in handle
prevTween = tween;

// Fire new tween with 1.0 second delay
tween = TweenFire(id, image_alpha__, EaseOutQuart, 0, true, 1.0, 3.0, 0, 1);

// Tell new tween to destroy previous tween when it starts to play
TweenAddCallback(tween, TWEEN_EV_PLAY, id, TweenDestroySafe, prevTween;

Returns: na

// Create a new tween
tween = TweenCreate(id);

// Tell tween to destroy itself (and its target) when finished or stopped
TweenDestroyWhenDone(tween, true, true);

Returns: bool

// Play tween if it exists
if (TweenExists(tween))
{
    TweenPlay(tween);
}

Returns: bool

// Play tween if it isn't already
if (TweenIsActive(tween))
{
    TweenPause(tween);
}

Returns: bool

// Play tween if it isn't already
if (TweenIsPlaying(tween) == false)
{
    TweenPlay(tween);
}

Returns: bool

// Play tween if it is stopped
if (TweenIsStopped(tween))
{
    TweenPlay(tween);
}

Returns: bool

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

Returns: na

// Pause all tweens including those associated with deactivated targets
TweenPauseAll(true, true);

Returns: na

// Pause all tweens of group 2, not including ones belonging to deactivated targets
TweenPauseGroup(2, false);

Returns: na

// Pause tweens associated with dude, except those belonging to deactivated targets
TweenPauseTarget(obj_Dude, false);

Returns: na

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

// Stop tween
TweenStop(tween);

Returns: na

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

// Pause tween
TweenPause(tween);

Returns: na

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

// Pause tween
TweenPause(tween);
// Resume tween
TweenResume(tween);

Returns: na

// Have tween immediately finish and not execute callbacks
TweenFinish(tween,false);

Returns: na

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

// Reverse tween direction
TweenReverse(tween);

Returns: na

// Step tween forward 1 step
TweenStep(tween, 1.0);

// Step tween forward 2 steps
TweenStep(tween, 2.0);

// Step tween back half a step
TweenStep(tween, -0.5);

Returns: na

// Have tween start to play immediately
TweenFinishDelay(tween,false);

Returns: real

// Ease value between 0 and 100 with amount of 0.75 using EaseInCubic
value = Ease(0, 100, 0.75, EaseInCubic);

Returns: null tween id

// Create null tween id
tween = TweenNull();

// Will not cause error
TweenPlay(tween);

Returns: tween id

// Create tween
tween = TweenCreate(id, x__, EaseInQuad, 0, true, 0.0, 3.0, x, mouse_x);

// Make copy of previously created tween
tweenCopy = TweenCopy(tween, other.id);

Returns: na

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

// Define tween
TweenDefine(tween, other, y__, EaseInQuart, TWEEN_MODE_PATROL, true, 0.0, 1.0, 0, 100);

// Play defined tween
TweenPlay(tween);

// Have following tweens belong to group 2
TweenSetGroup(TweenDefault(), 2);
// Have following tweens run at half speed
TweenSetTimeScale(TweenDefault(), 0.5);

// Fire tween -- will belong to group 2 and run at half speed
TweenFire(id, x__, EaseInQuart, 0, true, 0.0, 1.0, x, mouse_x);

Returns: na

// Execute 'TweenStop' for all tweens, including those with deactivated targets
TweensExecute(TWEENS_ALL, 0, true, TweenStop);
        
// Execute 'TweenPause' with tweens belonging to group 2
TweensExecute(TWEENS_GROUP, 2, false, TweenPause)
        
// Execute 'TweenSetTime' for tweens associated with obj_Jumpy
TweensExecute(TWEENS_TARGET, obj_Jumpy, false, TweenSetTime, 2.0);

Returns: array

// Play tween passing coordinates to extended parameters
TweenFire(id, ext_xy__, EaseInQuad, 0, true, 0.0, 1.0, x, mouse_x, y, mouse_y);

// Convert coordinates to array and pass as extended data. Will do the same as above.
var _coords = TPExt(x, mouse_x, y, mouse_y);
TweenFire(id, ext_xy__, EaseInQuad, 0, true, 0.0, 1.0, _coords);

Returns: real

// Fire tween with null property
tween = TweenFire(id, “”, EaseOutQuad, 0, true, 0.0, 1.0, 0, 100);

// Get eased value from tween's current state
value = TweenCalc(tween);

Returns: real

// Fire tween with null property
tween = TweenFire(id, “”, EaseOutQuad, 0, true, 0.0, 1.0, 0, 100);

// Get eased value from tween at 1/4 time
value = TweenCalcAmount(tween, 0.25);

Returns: real

// Fire tween with null property
tween = TweenFire(id, “”, EaseOutQuad, 0, true, 0.0, 12.0, 0, 100);

// Get eased value from tween at 5 seconds time
value = TweenCalcTime(tween, 5.0);

Returns: callback id

// Create tween
tween = TweenCreate(id);
// Show “Finished!” message when tween finishes playing
cb = TweenAddCallback(tween, TWEEN_EV_FINISH, id, ShowMessage, “Finished!”);

Returns: callback id

// Create tween
tween = TweenCreate(id);
// Execute user defined event '2' when tween finishes playing
cb = TweenAddCallbackUser(tween, TWEEN_EV_FINISH, id, 2);

Returns: na

// Create new tween
tween = TweenCreate(id);
// Add callback to FINISH event
cb = TweenAddCallback(tween, TWEEN_EV_FINISH id, ShowMessage, “Finished!”);
// Invalidate the added callback
TweenCallbackInvalidate(cb);

Returns: bool

/ Invalidate callback if it is valid
if (TweenCallbackIsValid(callback))
{
    TweenCallbackInvalidate(callback);
}

Returns: null callback id

// Nullify callback handle
cb = TweenCallbackNull();
// Does not cause error
TweenCallbackInvalidate(cb);

Returns: na

// Create new tween
tween = TweenCreate(id);
// Add callback to FINISH event
cb = TweenAddCallback(tween, TWEEN_EV_FINISH id, ShowMessage, “Finished!”);
// Disable callback
TweenCallbackEnable(cb, false);

// Invalidate callback if it is valid
if (TweenCallbackIsValid(cb))
{
    TweenCallbackInvalidate(cb);
}

Returns: na

// Create a new tween
tween = TweenCreate(id, x__, false);
// Add callback to PLAY event
TweenAddCallback(tween, TWEEN_EV_PLAY, id, ShowFireworks);
TweenAddCallback(tween, TWEEN_EV_PLAY, id, AddNumbers, 4, 15);
// Remove callbacks added to tween's PLAY event.
TweenEventClear(tween, TWEEN_EV_PLAY);

Returns: na

// Disable STOP event
TweenEventEnable(tween, TWEEN_EV_STOP, false);
// Stop tween -- STOP event callbacks won't execute
TweenStop(tween);

Returns: bool

// Disable PAUSE event if it is enabled
if (TweenEventIsEnabled(tween, TWEEN_EV_PAUSE))
{
    TweenEventEnable(tween, TWEEN_EV_PAUSE, false);
}

Returns: na

// Uses default step timing
TweenSimpleMove(x, y, mouse_x, mouse_y, 50, EaseOutQuint);

// Set simple tweens to use seconds timing
TweenSimpleUseDelta(true);

// Uses seconds(delta) timing
TweenSimpleRotate(0, 360, 2.0, EaseInOutSine);

Returns: tween id

// Move instance to mouse location
tween = TweenSimpleMove(x, y, mouse_x, mouse_y, 30, EaseInQuart);

Returns: tween id

// Scale instance to half size over 30 steps
tween = TweenSimpleScale(1.0, 1.0, 0.5, 0.5, 30, EaseInQuad);

Returns: tween id

// Rotate instance one full rotation over 30 steps
tween = TweenSimpleRotate(0, 360, 30, EaseOutQuad);

Returns: tween id

// Move instance to mouse location
tween = TweenSimpleMoveInt(x, y, mouse_x, mouse_y, 30, EaseInQuart);

Returns: tween id

// Fade in instance over 30 steps
tween = TweenSimpleFade(0.0, 1.0, 30, EaseInOutCubic);

Returns: tween id

// Play through an instance's sprite images over 100 steps
tween = TweenSimpleCycleImages(0, image_number-1, 100, EaseInSine);

Returns: tween id

// Change instance's image_blend from white to red over 30 steps
tween = TweenSimpleColour(c_white, c_red, 30, EaseInSine);

Returns: tween id

// Double an instance's speed over 60 steps
tween = TweenSimpleSpeedRamp(speed, speed*2, 60, EaseOutCubic);

Returns: tween id

// Ease hspeed and vspeed to 25% and 50% over 20 steps
tween = TweenSimpleHVSpeedRamp(hspeed, vspeed, hspeed*0.25, vspeed*0.5, 20, EaseOutQuint);

Returns: na

// Create tween and assign it to group 2
tween = TweenCreate(id, x__, false);
TweenSetGroup(tween, 2);

Returns: na

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

// Have tween run at 2x speed
TweenSetTimeScale(tween, 2.0);

// Have tween run at half speed
TweenSetTimeScale(tween, 0.5);

Returns: na

// Fire a tween
TweenFire(id, image_angle__, EaseInOutBack, 0, true, 0.0, 5.0, 0, 360);
// Jump tween to middle of duration
TweenSetTime(tween, 0.5*TweenGetTime(tween));

Returns: na

// Create a new tween
tween = TweenCreate(id);
// Assign tween a new target instance
TweenSetTarget(tween, obj_Player);

Returns: na

// Set tween to ease scale
TweenSetProperty(tween, scale__);
// Set tween to not be automatically calculated
TweenSetProperty(tween, "");

// Create tween which uses step timing
tween = TweenCreate(id, x__, EaseInOutQuad, 0, false, 0.0, 10, x, mouse_x);
// Switch tween to use delta(seconds) timing instead
TweenSetDelta(tween, true);

TweenSetStart(tween, 0);

// Fire tween
tween = TweenFire(id, y__, EaseInQuint, 0, true, 0.0, 1.0, y, mouse_y);
// Change tween's destination
TweenSetDestination(tween, mouse_y+100);

// Fire tween
TweenFire(id, image_scale__, EaseInQuad, 2, true, 0.0, 1.0, 1, 2);
// Double a tweens duration
TweenSetDuration(tween, 2*TweenGetDuration(tween)); 

// Fire a tween delayed by 5 seconds
TweenFire(id, image_alpha__, 0, EaseInOutQuad, true, 5.0, 1.0, 1, 0);
// Halve the active delay timer
TweenSetDelay(tween, 0.5*TweenGetDelay(tween));

// Create a defined tween with a 2 second delay
tween = TweenCreate(id, x__, EaseOutElastic, 0, true, 2.0, 1.0, x, mouse_x);
// Change the delay value for defined tween
TweenSetDelayStart(tween, 5.0);
// Play defined tween with updated delay value
TweenPlay(tween);

// Fire a tween
tween = TweenFire(id, x__, EaseLinear, TWEEN_MODE_ONCE, true, 0.0, 1.0, x, mouse);
// Change tween's mode to patrol
TweenSetMode(tween, TWEEN_MODE_PATROL);

// Fire a tween using linear ease
tween = TweenFire(id, x__, EaseLinear, 0, true, 0.0, 1.0, x, mouse_x);
// Update tween to use EaseInOutCubic
TweenSetEase(tween, EaseInOutCubic);

// Fire a tween with extended property
tween = TweenFire(id, ext_xy__, EaseOutQuad, 0, true, 0.0, 1.0, 0, 1, x, mouse_x, y, mouse_y);

// Change the extended data's x/y values
TweenSetExtData(tween, x, mouse_x+20, y, y-100);

// OR... Get existing extended data and modify it
extData = TweenGetExtData(tween);
extData[0] = extData[0]+100; // Update x1
extData[1] = 200; // Update x2
// Pass updated data back to tween
TweenSetExtData(tween, extData);

// OR... directly update extended data with '@' array reference accessor
extData[@ 2] = mouse_y - 100;  // Update y1
extData[@ 3] = extData[3]+100; // Update y2

// Pause tween if it belongs to specific group
if (TweenGetGroup(tween) == 2)
{
    TweenPause(tween);
}

Halve the time scale of a tween
TweenSetTimeScale(tween, 0.5*TweenGetTimeScale(tween));

Halve the progressed time of an active tween
TweenSetTime(tween, 0.5*TweenGetTime(tween));

Stop tween if it is associated with player
if (TweenGetTarget(tween) == obj_Player.id)
{
    TweenStop(tween);
}

Set the property of one tween to another
TwenSetProperty(tween1, TweenGetProperty(tween2));

Check tween for timing mode before updating its duration
if (TweenGetDelta(tween))
{
    TweenSetDuration(tween, 2.0);
}
else
{
    TweenSetDuration(tween, 2*room_speed);
}

Jump instance to a tween's starting x value
obj_Player.x = TweenGetStart(tween_x);

Jump instance to a tween's destination x value
obj_Player.x = TweenGetDestination(tween_x);

Double a tweens total duration
TweenSetDuration(tween, 2*TweenGetDuration(tween));

Double the remaining time of a delay counter
TweenSetDelay(tween, 2*TweenGetDelay(tween));

Double the delay for a defined tween when it is played
TweenSetDelayStart(tween, 2*TweenGetDelayStart(tween));
TweenPlay(tween);

Copy mode of one tween to another
TweenSetMode(tween1, TweenGetMode(tween2));

Copy ease of one tween to another
TweenSetEase(tween1, TweenGetEase(tween2));

Get a tween's extended data and modify it
extData = TweenGetExt(tween);
extData[0] = x; extData[1] = mouse_x;
extData[2] = y; extData[3] = mouse_y;
Assign updated extended data back to tween
TweenSetExtData(tween, extData);

// OR... modify the data directly using '@' array reference accessor
extData[@ 1] = 200;
extData[@ 3] = extData[3]+100;

Check if a tween's state is the same as another
if (TweenGetState(tween1) == TweenGetState(tween2))
{
    show_message("Tweens have same state!");
}

Show a tween's total change
show_message(TweenGetChange(tween));

// Pause tweening system if it is enabled
if (TweenSystemGetEnabled())
{
    TweenSystemSetEnabled(false);
}

// Double the current system's time scale
TweenSystemSetTimeScale(2*TweenSystemGetTimeScale());

// Have system update every 2 steps if update interval equals 1
if (TweenSystemGetUpdateInterval() == 1)
{
	TweenSystemSetUpdateInterval(2);
}

// Resume tweening system if not enabled
if (TweenSystemGetEnabled() == false)
{
	TweenSystemSetEnabled(true);
}

// Have tweening system run at half speed (slow motion)
TweenSystemSetTimeScale(0.5);

// Have tweening system update every 2 steps
TweenSystemSetUpdateInterval(2);

// Change minimum frame rate to 15
TweenSystemSetMinDeltaFPS(15);

// Increase number of tweens to be checked by memory-manager
TweenSystemSetAutoCleanIterations(30);

// Cache system's internal delta time value
tweenDelta = TweenSystemDeltaTime(true);
// Move player's x 100 pixels per second using tween system delta
obj_Player.x += 100*tweenDelta;

// Clear inactive tweening data for persistent room
TweenSystemClearRoom(rm_PauseScreen);

// Clear all inactive tweening data for all persistent rooms
TweenSystemClearAllRooms();

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

// Draw the total number of tweens in system
draw_text(x, y, TweenSystemCount());

// Draw the total number of playing tweens
draw_text(x, y, TweenSystemCountPlaying());

// Draw the total number of paused tweens
draw_text(x, y, TweenSystemCountPaused());

// Draw the total number of Stopped tweens
draw_text(x, y, TweenSystemCountStopped());

// Deactivate all objects
instance_deactivate_all(true);
// Reactivate shared tweener
SharedTweenerActivate();

// Clear the tweening system
SharedTweenerDestroy();