Examples

This page contains examples illustrating the GML-OOP workflow and if possible, compares them their native GML equivalents.

---

Data Structure usage

This example will use a List Data Structure for a basic demonstration on how Data Structures are interacted with in GML-OOP.
The following code will create a List, ensure it is empty, add three numbers to it, assign one of them to a variable and destroy the List.

Native GML

exampleList = ds_list_create();
ds_list_clear(exampleList);
ds_list_add(exampleList, 5, 20, 21);
var listValue = exampleList[| 1];
ds_list_destroy(exampleList);

GML-OOP

exampleList = new List();
exampleList.add(5, 20, 21);
var listValue = exampleList.getValue(1);
exampleList = exampleList.destroy();

The Data Structure created by a GML-OOP constructor can be interacted with through its methods. This is the recommended way of operating the Data Structure created by the constructor, however the reference to the actual Data Structure is held in its property in the ID variable and it can be still operated by the accessor (exampleList.ID[| 1]) and the native GML function (ds_list_find_value(exampleList.ID, 1)).

The List has been automatically cleared during the construction, but it still has to be manually destroyed when it is no longer intended to be used. Since the destroy() method will always return {undefined}, assigning its call to the reference of its own struct will dereference it, causing the Garbage Collector to clear it from the memory.

---

Particle Type configuration

This example will setup the properties of a Particle Type to demonstrate how GML-OOP interacts with the features of GameMaker, as well as how constructors can be operated through the with statement.

Native GML

exampleParticleType = part_type_create();

part_type_life(exampleParticleType, 150, 2500);
part_type_shape(exampleParticleType, pt_shape_disk);
part_type_scale(exampleParticleType, 0.25, 0.25);
part_type_size(exampleParticleType, 0.5, 0.5, 0, 0);
part_type_speed(exampleParticleType, 0.25, 1, 0, 0);
part_type_direction(exampleParticleType, 0, 359, 0.1, 0);
part_type_color_rgb(exampleParticleType, 0, 255, 0, 255, 0, 255);
part_type_alpha3(exampleParticleType, 1, 0.4, 0);

GML-OOP

exampleParticleType = new ParticleType();

with (exampleParticleType)
{
    setLife(new Range(150, 2500));
    setShape(pt_shape_disk);
    setScale(new Scale(0.25, 0.25));
    setSize(0.5);
    setSpeed(new Range(0.25, 1));
    setDirection(new Range(0, 359), 0.1);
    setColorRGB(new Range(55, 255), new Range(55, 255), new Range(55, 255));
    setAlpha(1, 0.4, 0);
}

Since GML-OOP operates on constructors, their methods can be called through the use of with statement, which can reduce the number of times a variable referring to them has to be mentioned. These methods treat arguments that are not absolutely necessary to execute a function as optional and can be skipped by not specifying them or using {undefined}. In that case, default values will be supplied to skip the use of the feature that the argument is responsible for. Some features in the above code, such as the ones responsible for increase and wiggle parts of the particle properties are not used, therefore the value of 0 has to be used in the native code for them and they can be omitted in GML-OOP.

All of the properties set using the above methods will be saved as properties of the constructor as they have been declared. Therefore, the declared properties, such as the speed of the particle can be read through exampleParticleType.speed, which will refer to the declared Range. Across different constructors, some of the properties saved in such way are used for further reference by the code of the constructor itself, whereas other are saved only for the manual reference by the user. The documentation page of each constructor lists which properties are freely modifiable without causing the constructor to become nonfunctional, as long as the new value is of a supported type.

---

Stringifying constructors

This example will illustrate the general way GML-OOP constructor are stringified, as each of them has a toString() method, which can be called manually and will automatically alter the result of using the variable referring to the constructor as an argument of the string() function. This method will return the name of the constructor and the most relevant information in curly brackets or a pair of angle brackets if the constructor is not functional.

Setup

exampleVector2 = new Vector2(5, 50);
exampleSprite = new Sprite(TestSprite);
exampleList = new List();
exampleStack = new Stack();
exampleMap = new Map();
exampleList.add("GML-OOP", 55555, exampleSprite);
exampleStack.add("GML-OOP", [5, 25, 125, 625, 3125], exampleVector2);
exampleMap.destroy();

var result_Vector2 = string(exampleVector2);
var result_List = exampleList.toString();
var result_Stack = exampleStack.toString(true, all, all);
var result_Map = exampleMap.toString();

Result: Vector2

Vector2(x: 5, y: 50)

Result: List

List(3 - GML-OOP, 55555, Sprite("TestSp...)

Result: Stack

Vector2(x: 5, y: 50)
[ 5,25,125,625,3125 ]
GML-OOP   

Result: Map

Map<>

The output of Data Structures is shortened, as they can have a potentially infinite number of values inside of them. The constructors that are not functional because they are invalid or have been destroyed will output the name of the constructor and then a pair of angle brackets, as exemplified above with the destroyed Map constructor.

Calling the toString() method of a constructor allows for configuration of the resulting string through its arguments. This has been done in the above example with the Stack constructor to make the output multiline, as well as to change the number of elements shown and their length, in which case the all constant removed these limits.

---

Method chaining

Each GML-OOP constructor method that is not documented to return anything will return {self}. It is the reference to the constructor of which the method was called. Calling a method directly off that result allows for multiple calls of methods of the same constructor by mentioning the starting constructor only one time. This is comparable to the use of the with statement, however it does not change the scope in which the code is currently executed. If a method returns a value, it cannot be chained from, unless that value is another struct containing a callable method.

Setup

exampleVector2 = new Vector2(5, -15);

Inline

var result = exampleVector2.add(5).multiply(-1).sum(exampleVector2).x;

Multiline

var result = exampleVector2
	      .add(5)
	      .multiply(-1)
	      .sum(exampleVector2)
	      .x;

The methods in a chain are executed in order from closest to the reference to the constructor. Its values are updated instantly with each call, allowing for seamless operations, including the constructor using itself as an argument. The chain can be continued on a new constructor that was returned as a part of it. It can also end on a value that does not allow further chaining, which can then be read as the result.

Changes in whitespace are allowed in such chains if they are not breaking the names of their elements. The use of semi-colon is allowed only after the final element.