GMLscripts.com

Expand///	@description	Returns whether a test value is between 2 other values
///	@arg	{real}	test		The value to test
///	@arg	{real}	minimum		The low value in the range
///	@arg	{real}	maximum		The high value in the range
///	@arg	{bool}	*Inclusive	Include min and max in the check
///	@returns	{bool}	Whether the test value is between the min and max
/*
*	Simply turns the all-too-common check into a single plain-English command. Inclusive flag optional
*	Also works with inverted ranges, eg the min is really the max 
*	and the max is really the min. This saves the trouble of needing
*	to pre-sort the values before testing.
*/
var test = argument[0];
var low = argument[1];
var hig = argument[2];
var inc = false;
if(argument_count>3){
	inc = argument[3];
}
if(inc){
	if( (test>=low && test<=hig) || (test<=low && test>=hig) ){
		return true;
	}else{ return false; }
}else{
	if( (test>low && test<hig) || (test<low && test>hig) ){
		return true;
	}else{ return false; }
}

Expand///@description		point_on_rectangle(x, y, minX, minY, maxX, maxY)
///@arg	{real}	x		Coordinate of point outside rectangle
///@arg	{real}	y		Coordinate of point outside rectangle
///@arg	{real}	minX	Left X of box
///@arg	{real}	minY	Top Y of box
///@arg	{real}	maxX	Right X of box
///@arg	{real}	maxY	Bottom Y of box
/*
*	Note that this is not point_IN_rectangle
*
*	Returns the coordinates where a line between the
*	center of a rectangle and a given point intersects
*	the rectangle.
*/

var px = argument[0];
var py = argument[1];
var minX = argument[2];
var minY = argument[3];
var maxX = argument[4];
var maxY = argument[5];
var r = -1;
	
if (minX <= px && px <= maxX) && (minY <= py && py <= maxY){
	// Point should not be inside the rectangle!
	return r;
}
var midX = (minX + maxX) / 2;
var midY = (minY + maxY) / 2;
// if (midX - x == 0) -> m == ±Inf -> minYx/maxYx == x (because value / ±Inf = ±0)
var m = (midY - py) / (midX - px);

if (px <= midX) { // check "left" side
	var minXy = m * (minX - px) + py;
	if (minY <= minXy && minXy <= maxY){
		r[0] = minX; r[1] = minXy;
		return r;
	}
}

if (px >= midX) { // check "right" side
	var maxXy = m * (maxX - px) + py;
	if (minY <= maxXy && maxXy <= maxY){
		r[0] = maxX; r[1] = maxXy;
		return r;
	}
}

if (py <= midY) { // check "top" side
	var minYx = (minY - py) / m + px;
	if (minX <= minYx && minYx <= maxX){
		r[0] = minYx; r[1] = minY;
		return r;
	}
}

if (py >= midY) { // check "bottom" side
	var maxYx = (maxY - py) / m + px;
	if (minX <= maxYx && maxYx <= maxX){
		r[0] = maxYx; r[1] = maxY;
		return r;
	}
}

// Somehow...
show_debug_message("Something didn't work in point_on_rectangle");
return r;

Expand///	@description		Returns whether a value is in the supplied set of arguments
///	@function			is_in( value, test0, [test1], [...] )
///	@param				value	The value to search for
///	@param				test0	Value to compare to
///	@param				[test1]	Add parameters as needed to extend the set
///	@returns	{bool}	True when value was found in set
/*
*	Suppose we want to test whether x, y, or z is equal to value.
*	GameMaker:
*		if(x==value || y==value || z==value)
*	Python:
*		if value in {x, y, z}
*	This script shortens what you'd have to type in GameMaker like so:
*		if is_in(value, x, y, z)
*		Also accepts an array: 
*			array = [x, y, z];
*			if is_in(value, array)
*/
// Created for SLIDGE engine
// GMLscripts.com/license

var test = argument[0];
var argz = 0;
for(var z=1; z<argument_count; z+=1){
	argz = argument[z];
	if(is_array(argz)){
		for(var i=0; i<array_length_1d(argz); i+=1){
			if(test == argz[i]){
				return true;
			}
		}
	}else{
		if(test == argument[z]){
			return true;
		}
	}
}
return false;

Expand/// array_insert_2d(array, value, row, column);
//
//  Accepts a 2D array and modifies the array to insert
//  a desired value. If the insertion location is
//  outside of the array, devault values are padded.
//
//      array   : The name of a 2D array
//      value   : The value to insert
//      row     : The first dimension index to insert into
//      column  : The second dimension index to insert into
//
//  To avoid duplicating large 2D arrays, the @ accessor is used.
//  No value is returned from the script, as the array is already modified
//
//  This script performs an Insertion, not an overwrite, so expect the 
//  length of the second dimension to change.
//
/// GMLscripts.com/license

var defaultValue = 0; // Used when inserting past the end of an array

var ar = argument[0];
var val = argument[1];
var row = argument[2];
var col = argument[3];

var L1 = array_height_2d(ar);
while(row>=L1){
    // Pad rows up to the one needed
    ar[@L1,0] = defaultValue;
    L1 = array_height_2d(ar);
}

var L2 = array_length_2d(ar,row);
while(col>=L2){
    // Pad columns up to the one needed
    ar[@row,L2] = defaultValue;
    L2 = array_length_2d(ar,row);
}
/*
*   Note on padding:
*
*   Given:
*   |1|2|
*   |3|4|
*
*   array_insert_2d(array, "A", 2, 1)
*
*   Results in:
*   |1|2|
*   |3|4|
*   |0|A|0|
*
*   An extra row was padded, then data up to index 1 was padded
*   Then, the data is inserted (below)
*/

for(var z=L2; z>col; z-=1){
    // Ripple all data forward by one at the desired row,col
    ar[@row, z] = ar[row, z-1];
}
// Set the value at the intended coordinates.
ar[@row,col] = val;