NTGML's syntax extensions

You can define functions in NTGML mods like you define them in GML scripts:

function step() {
    // ...
}
trace("hi!")
function add(a, b) {
    return a + b;
}

Any code outside of functions will be automatically added to the init function that runs when your mod is loaded.

You may also define functions similar to how it's done in GM extensions:

trace("hi!");
#define step
// ...
#define add(a, b)
return a + b;

Any code before the first function will be added to the init function.

A small convenience is added support for named arguments, which GM extensions do not have.

You may use either of formats, but not both at once;
Legacy format can only use #define-based declarations.

You can do a with on an array of structs/instances in NTT.

I slightly regret not making this a separate keyword as it can be a source of occasional sabotage.

This is a convenience operator that can be used in place of variable_instance_exists / struct_exists.

Used like so:

if (variable_instance_exists(self, "count")) {
    count += 1;
} else count = 1;
// ↕ same as
if ("count" in self) {
    count += 1;
} else count = 1;

Or even:

count = (("count" in self) ? count : 0) + 1;

Also supports negation:

if (!variable_instance_exists(inst, "my_mod_mark")) { /* ... */ }
// ↕ same as
if ("my_mod_mark" not in inst) { /* ... */ }

NTGML supports C#/GM2023+ style $"" template strings, so you can do this:

#define draw_gui
with (Player) {
    draw_text(10, 50, $"HP: {my_health}/{maxhealth}");
    break;
}

but JS-style template strings are also supported:

#define draw_gui
with (Player) {
    draw_text(10, 50, `HP: ${my_health}/${maxhealth}`);
    break;
}

In legacy format, only JS-style template strings are supported.

You can suspend scripts mid-execution. For example,

for (var i = 1; i <= 5; i++) {
    trace(i);
    wait 30;
}

would count up to 5 while waiting 30 frames / 1s between each iteration.

This allows for some interesting things. For example, to make an explosive bullet for a custom weapon, you could wait for projectile to be destroyed while tracking it's position:

#define weapon_fire
motion_add(gunangle, -4);
weapon_post(6, -7, 5);
// create and configure a projectile:
var qx = x, qy = y;
var q = instance_create(qx, qy, HeavyBullet);
with (q) {
    team = other.team;
    motion_add(other.gunangle + random_range(-5, 5), 1);
    friction = -0.8; // gradual acceleration
    image_angle = direction;
}
// track projectile' position while it exists:
while (instance_exists(q)) {
    qx = q.x + q.hspeed;
    qy = q.y + q.vspeed;
    wait 1;
}
// create an explosion at it's last position once it's gone:
instance_create(qx, qy, SmallExplosion);

Note that if you wait in a script that should return something to the game immediately (like character/weapon names), the game will assume that you didn't return anything.

fork() is a "function" that creates a copy of the currently running script state.

The copy will have its own (re-assigned) local variables but will share the rest of the state.

The copy will execute the current script and finish while the original will continue executing as normal.

The "function" returns true to the copy and false to the original.

Thus,

if (fork()) {
    trace("fork");
} else trace("orig");
trace("post");

would output

fork
post
orig
post

as the copy executes before the original resumes.

If you were to add a wait call into the copy,

if (fork()) {
    trace("fork");
    wait 1;
} else trace("orig");
trace("post");

the original would resume as soon as the copy suspends:

fork
orig
post [from orig]
[1 frame passes]
post [from fork]

A common use case for fork is executing something involving wait

#pragma

These are preprocessor directives.

global.count = 0;
function next() {
    global.count += 1;
    return global.count;
}

#pragma include tools.gml
trace(global.count);
trace(next());

global.count = 0;
function next() {
    global.count += 1;
    return global.count;
}

#pragma using tools.mod.ntgml

function my_func() {
    // ...
}
function my_func_helper() {
    #pragma no_using
    // ...
}

function my_func() {
    #pragma fast
}