Better moving platforms

This article is about better moving platforms in GameMaker. I previously covered a way of doing simple moving platforms (both vertical and horizontal). They can carry the player without glitches. Unfortunately they have a severe limitation: they can’t carry more than one instance. For example, if two entities jump on a moving platform, almost all entities won’t be able to correctly collide with it.

Why is this happening?

The moving platforms code is simple. Too simple, actually. Indeed it checks for one collision, and only one, with a single instance of oPlayer and then it tries to move that instance before carrying out its own movement. If there’s more than one oPlayer instance, it doesn’t work.

How to fix the moving platforms

Fixing the problem is simple, in principles, since GameMaker Studio 2 introduced the collision_*_list functions. These functions return a list of multiple instances colliding with the calling instance. Then we will cycle through the found instances and move them one by one.

coll_x_list and coll_y_list

I created a couple of utility scripts for the GMS2 collision_rectangle_list function. I know I will pass an xdir or a ydir, a ds_list reference and the object_index for which we’re checking the collision. The function will automatically fill the ds_list and return the number of instances found, just like the collision_rectangle_list. I made these scripts simply because I didn’t want to type all the bbox_* and collision parameters each time. Sometimes being lazy helps you being organized.

coll_x_list

///@func coll_x_list(xdir, instances_ds, obj)

var xdir            = argument[0]
var instances_ds    = argument[1]
var obj             = argument[2]

var side_to_check = xdir ? bbox_right + 1 : bbox_left - 1

return collision_rectangle_list(side_to_check, bbox_top, side_to_check, bbox_bottom, obj, false, true, instances_ds, false)

coll_y_list

///@func coll_y_list(ydir, instances_ds, obj)

var ydir            = argument[0]
var instances_ds    = argument[1]
var obj             = argument[2]

var side_to_check = ydir ? bbox_bottom + 1 : bbox_top - 1

return collision_rectangle_list(bbox_left, side_to_check, bbox_right, side_to_check, obj, false, true, instances_ds, false)

These scripts should be called from the move_platform_x and move_platform_y scripts.

Fixing the horizontal platform

We will start from the horizontal platform so open up the move_platform_x script and let’s take a look at it.

In point 1 we’re concerned with the player eventually colliding on the sides.

In point 2 we’re actually carrying the player. As you notice this is quite simple. We’re going to add more complexity as we’re now dealing with a ds_list and with for loops.

In point 1 we create a instances_ds (_ds stands for data structure as we’re creating a ds_list). This list will hold the colliding instances found.

In point 2 we pass the aforementioned instances_ds (along with other required parameters) to the actual collision check script. This will fill the list and return the number of colliding instances (which we store in the num_found variable).

In point 3 we iterate through the found instances and we move them one by one. Note that there is no need to test if num_found > 0 because for already tests that in the i < num_found condition.

Please note that if we cannot move one of the found instances, we return false as we did before. We just ensure to delete the instances_ds to avoid memory leaks. Always delete useless data structures before returning from scripts.

In point 4 we clear the instances_ds because we need a clear ds_list (otherwise we’d create a mess in the next points).

In point 5 we basically do the same thing as in point 2 but this time we check for collisions above.

In point 6 we cycle and try to move each one of the found instances. Just like the previous version, we don’t need to return anything as we don’t really care if the instance above can or cannot move. It doesn’t influence the moving platform.

In point 7 we cleanup the ds_list to avoid memory leaks and then, finally, move the platform horizontally.

Fixing the vertical platform

This is a little bit trickier but it’s totally the same thing.

In point 1 and 2 we’re inside a platform that is going downward (because the ydir is positive). We can collide with what’s below us but we also need to carry the player with us. In point 3 we’re going upward so we can only collide with what’s above us.

To adapt this code, the principle is the same. We prepare a list, we use our coll_x_list and coll_y_list scripts to check for collisions and then we cycle the colliding instances. Due to the length of the code, I’ve split the screenshots in two.

Going downward

The gist is very similar to the horizontal movement. Notice that we still apply the instance_deactivate_object(self) trick in point 7 to avoid collision during the player’s movement downward. It’s pretty much the previous code, adapted with for loops and a list. Again: remember to destroy your data structures if you need to return from this script or when you don’t use them anymore.

Going upward

Same process. Get the instances, loop, destroy the lists whenever we return or don’t need them anymore. Finally move the platform.

Even better moving platforms (there’s a bug)

There’s something off with this implementation. Fact is that we return false during a for loop in which we might have already moved some instances.

Another approach would be to split the movement and the collision checks in two parts. We temporarily store the instances that could be moved inside another list. After we finish our checks, ensuring each instance could move, we move them all. Otherwise we destroy the lists and avoid any movement at all (both players and platforms).

Either of these approaches should work. I tried both and it really depends on your engine. If you use another approach, let me know in the comments. I’d like to know about it. We’ll go with the first approach.

Reset the positions with instances_reset_position()

Let’s create another little utility script called instances_reset_position(). This script will accept a ds_list. This list is the one we use to keep track of the instances moved.

///@func instances_reset_position(instances_to_move)

var instances_to_move    = argument[0]
var num_of_instances     = ds_list_size(instances_to_move)
var index                = 0

repeat(num_of_instances)
{
    var instance      = instances_to_move[| index]
    instance.x        = instance.xprevious
    instance.y        = instance.yprevious
    index++
}

As you can see, we cycle through the list and simply reset the instance.x to its instance.xprevious (same for the y position, of course).

move_platform_x – fixed

1. Create the list to keep track of the moved instances
2. Add the instance to this list
3. In case we cannot move any of the instance in the current loop, pass the above list to our function (to reset their positions). Just before returning, destroy the list to avoid memory leaks.
4. As usual, cleanup the lists.

move_platform_y – fixed

1. Create the list
2. Add the instance
3. Reset position if we fail to move
4. Add the instance (do not clear the list, we need to keep track of the previously moved instances as well)
5. Reset position of all the instances if we fail to move any of the instances
6. Cleanup

The End (not so fast!)

Be sure to read the latest article about fixing a bug in this very project (yes, there’s still a little bug). It affects high speed (i.e. > 1) moving platforms.

As you might have read, YoYo Games released the beta of GameMaker Studio 2.3. While you could import the project into 2.3, this blog post cannot be replicated step by step, writing these scripts as they are, without any modification.

For this reason, I am now rewriting this whole guide for the 2.3 version. I’ll take into account the new features of GameMaker Studio 2.3. I don’t know how much time will pass before the 2.3 gets a public release (as I still have to get my beta access), but I already got a good look at how functions and structs work so I am planning ahead the complete rewrite.

Hope this article was useful to someone. Stay safe.