How to Make a Multiplayer Game

rollback_define_input(
{
        left: vk_left,
        right: vk_right,
        up: vk_up,
        down: vk_down,
        mb_x: m_axisx,
        mb_y: m_axisy,
        fire: mb_left
});

You need to add this at the top of the event, before a multiplayer game is joined or created. You can’t change inputs after a game has been initiated.

        left: ord("A"),
        right: ord("D"),        
        // or, use both:
        up: [vk_up, ord("W")],
        down: [vk_down, ord("S")],

image_angle = point_direction(x, y, _input.mb_x, _input.mb_y);

As always, the “AI” player (pff) continues to receive random input.

So Anyway, I Started Blasting

You already created obj_projectile earlier in the tutorial. Now, spawn it when the player presses fire.

Open obj_player’s Step event.

At the end, add this:

if (_input.fire)
{
        var _proj = instance_create_layer(x, y, layer, obj_projectile);
        
        _proj.speed = 10;
        _proj.direction = image_angle;
        _proj.image_angle = image_angle;
        _proj.player = self;
}

If the fire input is held, this will:

1. Create an instance of obj_projectile, at the player’s position and in the same layer
   
2. Store its ID in a variable
   
3. Through that ID, it will set some variables in the projectile:

• speed, how fast it moves
• direction, where it moves
• image_angle, where it faces
• player, which is a reference of the player that created it

Run the game, press LMB and see the bullets go:

It’s, uhh… a bit like firing a water gun. Bullets should be a bit more controlled.

Let’s make it fire only when the mouse button is hit, and to fire a second time, you have to release and press it again.

Press it. Hold it. Release it.

Each defined input checks if the key is held down, like fire or left.

However, GameMaker also provides a *_pressed variant, which checks if the key was just pressed in the same frame.

It also provides a *_released variant to check if the key was just released.

Fix It

In your player’s Step event, go to the code you added last. The one that handles firing.

The condition there checks if for _input.fire:

In GML Code, change this to:

if (_input.fire_pressed)

In GML Visual, change the action to "If Key Pressed (Rollback)":

Run the game, and you can now only fire when you press LMB – holding does nothing.

Respawning

Where’s the action?!

Projectiles ain’t worth nothing if there’s no one to defeat.

It’s time to program collisions between a player and a projectile.

When the projectile hits a player, that player should:

1. Show a particle effect
2. Jump to a random position in the room, effectively “respawning”
3. Destroy the projectile

And, it should only do all this if the projectile belongs to a different player.

You don’t want your own projectile to hit yourself, do you?

What’s That In Code?

Open obj_player, then add a Collision event with obj_projectile.

This event runs when a player and a projectile overlap in the room.

Add this code here:

if (other.player == self) exit;

effect_create_above(ef_ring, x, y, 0, c_white);
        
x = irandom_range(40, room_width - 40);

y = irandom_range(40, room_height - 40);
        
instance_destroy(other);

When creating a projectile, you’ll remember that we set the player variable to the self of the firing player.

GML Code

GML Visual

The condition in your new event checks if the projectile that hit you, is the same projectile that you fired.

Obviously, that shouldn’t hurt you. So, we exit the event, stopping the code’s execution.

The rest of the code then:

1. Creates a “ring” effect at the player’s position, with a white colour.
2. Sets the X position to a random value between 40 and room_width - 40.
3. Sets the Y position to a random value between 40 and room_height - 40.
4. Destroys the other instance, which is the projectile.

Scoring

You can now fire at the other player, and upon hitting, that player gets respawned.

But it’s not really fun until you can count it, is it?

Let’s add scoring: each hit increases a player’s points, which are displayed on the player.

A 3-Step Plan

Follow the three quick steps below to add scoring to the player object.

All of these are done in obj_player.

Step 1

Open the Create event, and create a points variable:

points = 0;

Step 2

Add the Draw End event, which runs after the game has been drawn.

In this event, draw the player’s points:

draw_text(x, y - 24, points);

The points text is drawn 24 pixels above the player.

Step 3

When a projectile hits you, increase the points in the attacking player.

Open the Collision event with obj_projectile.

At the end, add this:

other.player.points ++;

This gets the player from the projectile, and from that player, gets the points variable. It increases that variable by 1.

Are We There Yet?

We are.

Run the game, and with each player you take down, you get one point.

Hopefully real players aren’t as good as this AI, wow. Sweaty players smh.

Drawing Names

Each player gets a player_name variable, which you can draw to the screen.

For example, I’ll change the player's Draw End event to this:

draw_text(x, y - 24, player_name + ": " + string(points));

This will draw the player’s username along with their points:

To use a different font, create a new font asset, and apply it using draw_set_font() before you draw your text.

How to Mark The Local Player?

It might become hard to tell which player you are.

The solution is simple: use the player_local variable to draw something that tells you which player you’re controlling.

In obj_player’s Draw End event, I’ll add this:

if (player_local)
{
        draw_sprite(spr_arrow, 0, x, y - 12);
}

If the player is local, it draws an arrow sprite above it – you can go ahead and quickly make this sprite in GameMaker.

The player_local variable should only be used for visual effects, like we did above. Don’t use it to program different behaviour for your local player: all players should have the same behaviour given the same input.

In-game, you will now see that arrow on your player:

Note on State

You can’t change your game’s “state” before all players have joined.

The state consists of all objects that contribute to gameplay.

For this purpose, you can use the Rollback Start event, which runs when the game begins – after all players have joined.

For example, if you have an alarm that spawns enemies every second, start that alarm in the Rollback Start event.

You can also use the rollback_game_running variable, which becomes true after the game starts.

This ensures that you’re not creating any managed instances before the game starts, and getting yourself a fatal error.

What’s Next?

Read the manual to discover all you can do with Rollback.

Add multiplayer to an existing game.

Most importantly, play around with GameMaker. Get in there, make something, no matter how small.

Happy GameMaking!