If you remember

This is a post about how to call a function from a parent constructor in a same-named function in a child constructor and how static works in GameMaker Language in general.

What's a static, anyway

static in functions

Static variables persist between calls to the function:

function make_id() {
    static _id = 0;
    _id += 1;
    return _id;
}
trace(next_id()); // 1
trace(next_id()); // 2

This is similar to how static works in C++.

static in constructors

When used inside a constructor, it works the same as above, but also GM will look up any missing variables in a struct's constructor's statics:

function Test() {
    static a = 1;
    b = 2;
}
var test = new Test();
trace(test.a); // 1
trace(struct_exists(test, "a")); // false
trace(test.b); // 2
trace(struct_exists(test, "b")); // true

This is similar to how prototypes work in JavaScript.

Variables that aren't in a struct don't take up memory in it, which is particularly convenient for variables that are unlikely to be changed - such as methods!

static "sharing"

It might be tempting to mark all of your variables as static, but watch out! When used with by-reference types like arrays and structs, all of the structs will share that value:

function Test() constructor {
    static array = [];
}
var a = new Test();
var b = new Test();
trace(a.array); // []
trace(b.array); // []
array_push(a.array, 1);
trace(a.array); // [1]
trace(b.array); // [1] <- !!

To avoid this, give a struct a personal variable before modifying it:

function Test() constructor {
    static array = [];
}
var a = new Test();
var b = new Test();
trace(a.array); // []
trace(b.array); // []
a.array = [];
array_push(a.array, 1);
trace(a.array); // [1]
trace(b.array); // [] <- OK!

static inheritance

Just like how struct variables take priority over the constructor's statics, constructor's statics take priority over those from parent constructor(s):

function Par() constructor {
    static a = 1;
    static b = 2;
}
function Ctr() : Par() constructor {
    static b = 3;
    static c = 4;
}
var q = new Ctr();
trace(q.a); // 1
trace(q.b); // 3
trace(q.c); // 4

Method overriding

And with all that out of the way, we're finally here! Suppose you have the following

function Dog() constructor {
    static bark = function() {
        return choose("bof", "woof");
    }
}
function LoudDog() : Dog() constructor {
    static bark = function() {
        return string_upper(/*parent's bark*/());
    }
}

You cannot simply do bark() because that would refer to LoudDog's bark and lock up your program in a recursive call.

But there are options:

Modern

This works starting in whatever version where support for Script.staticVar was added. It does not work in LTS 2022.

function Dog() constructor {
    static bark = function() {
        return choose("bof", "woof");
    }
}
function LoudDog() : Dog() constructor {
    static bark = function() {
        return string_upper(Dog.bark());
    }
}

Static functions do not have a bound self so the call will use the current struct and it all works out!

Classic

This works in any version that has constructors.

function Dog() constructor {
    static bark = function() {
        return choose("bof", "woof");
    }
}
function LoudDog() : Dog() constructor {
    static Dog_bark = bark;
    static bark = function() {
        return string_upper(Dog_bark());
    }
}

Here we store the original bark() (from the parent constructor) before defining the one for LoudDog.

Performance

If you are doing this in a performance-critical context, I regret to inform that the "classic" method is 13..20% faster than the nicer-looking Dog.bark():

GMBenchmark code:

function Dog() constructor {
    static bark = function() {
        return 1;
    }
}
function LoudDog_dot() : Dog() constructor {
    static bark = function() {
        return Dog.bark();
    }
}
function LoudDog_rev() : Dog() constructor {
    static Dog_bark = bark;
    static bark = function() {
        return Dog_bark();
    }
}
Benchmarks = [
    new Benchmark("Overrides", [
        new TestCase("Parent.func()", function(iterations) {
            repeat (iterations) ldd.bark();
        }, function() {
            ldd = new LoudDog_dot();
        }),
        new TestCase("Parent_func()", function(iterations) {
            repeat (iterations) ldr.bark();
        }, function() {
            ldr = new LoudDog_rev();
        }),
    ]),
];

Bonus: caching

Bonus! Tero Hannula (drandula on GM forums) pointed out that you could cache the parent function in a static of a child function, like so:

function Dog() constructor {
    static bark = function() {
        return choose("bof", "woof");
    }
}
function LoudDog() : Dog() constructor {
    static bark = function() {
        static super = Dog.bark;
        return string_upper(super());
    }
}

Unfortunately, as of 2024.8 this is still slower than the "classic" approach. Implementation details?

And that's about it..?

Ah! But hold on, I have more dogs that I drew while figuring out what to use for the post intro image:

Related posts:

• GameMaker: trace/log function with position information
• GameMaker: DIY closures
• GameMaker: Homing missiles
• GameMaker: Windows extensions FAQ
• Building a better localization system for GameMaker