Little Helpers

This is a group of helper functions that did not fit anywhere else and are too few (and too small) to get their own script for each.

is_between
is_between_ex

Test, if the specified value is between the lower_bound and the upper_bound, where
is_between tests the range including both bounds, and
is_between_ex tests excluding both bounds.

/// @function			is_between[_ex](val, lower_bound, upper_bound)
/// @description		test if a value is between lower and upper bounds
/// @param {real/int} value
/// @param {real/int} lower_bound
/// @param {real/int} upper_bound
/// @returns {bool} y/n

is_any_of

/// @function			is_any_of(val, ...)
/// @description		Specify any number of parameters after "val".
///				Determines if val is equal to any of them.
/// @param {any} val	The value to find
/// @param {any} ...	List of values to search
/// @returns {bool}	y/n

percent
percent_mult

Gets, how many % value is of total.
percent returns the full value (Example: val 30, total 50 -> returns 60(%)) and
percent_mult returns a multiplier for the value, so 0.6 instead of 60.

/// @function		percent(val, total)
/// @description	Gets, how many % "of" is of "total"
/// @param {real} val	The value
/// @param {real} total	100%
/// @returns {real}	How many % of total is val. Example: val 30, total 50 -> returns 60(%)

is_child_of

GameMaker's object_is_ancestor has a little flaw: It returns false if the object is exactly the ancestor. If you test object_is_ancestor(myGameObject, myGameObject) you receive false because it is not derived from myGameObject.
This function here will return true in this case (and also uses object_is_anchestor, so you get the same results, except that the case child==parent also returns true).

/// @function					is_child_of(child, parent)
/// @description				True, if the child is exactly parent type or derived from it
/// @param {object_index} child
/// @param {object} parent
/// @returns {bool}

run_delayed
run_delayed_ex

Executes the specified func after a waiting time of delay frames.

NOTE: The Animation ListPool is used to count the frames, as the functionality uses an internal raptor function to achieve the delay. Keep in mind, that calling animation_abort_all on the owner specified here will also stop this delayed execution.
run_delayed_ex runs the function exclusively, and invokes animation_abort_all before starting the waiter.

/// @function		run_delayed[_ex](owner, delay, func, data = undefined)
/// @description	Executes a specified function in <delay> frames from now.
///			Behind the scenes this uses the __animation_empty function which
///			is part of the ANIMATIONS ListPool, so if you clear all animations,
///			or use animation_run_ex while this is waiting for launch, 
///			you will also abort this one here.
///			Keep that in mind.
/// @param {instance} owner	The owner of the delayed runner
/// @param {int} delay		Number of frames to wait
/// @param {func} func		The function to execute
/// @param {struct} data	An optional data struct to be forwarded to func. Defaults to undefined.
/// @param {int} repeats	An optional repeat counter. Default to 1. A value of -1 means "forever".