17. Remote Procedure Calls

Overview

In this chapter, you will be introduced to Remote Procedure Calls, which is another important multiplayer concept of Unreal Engine 4's Network Framework. You'll also learn how to use enumerations in Unreal Engine 4 and how to use bi-directional circular array indexing, which is a way to help you iterate arrays in both directions and be able to loop around when you go beyond its index limits.

By the end of this chapter, you'll understand how Remote Procedure Calls work to make the server and the clients execute logic on one another. You'll also be able to expose enumerations to the Unreal Engine 4 editor and use bi-directional circular array indexing to cycle through arrays.

Introduction

In the previous chapter, we covered some critical multiplayer concepts, including the server-client architecture, connections and ownership, roles, and variable replication. We also saw how the listen server is quicker to set up compared to the dedicated server but is not as lightweight. We used that knowledge to create a basic first-person shooter character that walks, jumps, and looks around.

In this chapter, we're going to cover Remote Procedure Calls (RPCs), which is another important multiplayer concept that allows the server to execute functions on the clients and vice versa. So far, we've learned variable replication as a form of communication between the server and the clients, but that won't be enough, because the server might need to execute specific logic on the clients that doesn't involve updating the value of a variable. The client also needs a way to tell its intentions to the server, so that the server can validate the action and...

Remote Procedure Calls

We've covered variable replication in Chapter 16, Multiplayer Basics, and, while a very useful feature, it is a bit limited in terms of allowing the execution of custom code in remote machines (client-to-server or server-to-client) for two main reasons:

• The first one is that variable replication is strictly a form of server-to-client communication, so there isn't a way for a client to use variable replication to tell the server to execute some custom logic by changing the value of a variable.
• The second reason is that variable replication, as the name suggests, is driven by the values of variables, so even if variable replication allowed the client-to-server communication, it would require you to change the value of a variable on the client to trigger a RepNotify functionality on the server to run the custom logic, which is not very practical.

To solve this problem, Unreal Engine 4 supports RPCs. An RPC works just like a normal...

Enumerations

An enumeration is a user-defined data type that holds a list of integer constants, where each item has a human-friendly name assigned by you, which makes the code easier to read. As an example, we could use an integer variable to represent the different states that a character can be in – 0 means it's idle, 1 means it's walking, and so on. The problem with this approach is that when you start writing code such as if(State == 0), it will become hard to remember what 0 means, especially if you have a lot of states, without using some documentation or comments to help you remember. To fix this problem, you should use enumerations, where you can write code such as if(State == EState::Idle), which is much more explicit and easier to understand.

In C++, you have two types of enums, the older raw enums and the new enum classes, introduced in C++11. If you want to use C++ enumerations in the editor, your first instinct might be to do it in the typical way,...

Bi-Directional Circular Array Indexing

Sometimes, when you use arrays to store information, you might want to iterate it in a bi-direction circular fashion. An example of this is the previous/next weapon logic in shooter games, where you have an array with weapons and you want to be able to cycle through them in a particular direction, and when you reach the first or the last index, you want to loop back around to the last and first index, respectively. The typical way of doing this example would be the following:

AWeapon * APlayer::GetPreviousWeapon()
{
  if(WeaponIndex - 1 < 0)
  {
    WeaponIndex = Weapons.Num() - 1;
  }
  else WeaponIndex--;
  return Weapons[WeaponIndex];
}
AWeapon * APlayer::GetNextWeapon()
{
  if(WeaponIndex + 1 > Weapons.Num() - 1)
  {
    WeaponIndex = 0;
  }
  else WeaponIndex++;
  return Weapons[WeaponIndex]...

Summary

In this chapter, you learned how to use RPCs to allow the server and the clients to execute logic on one another. We also learned how enumerations work in Unreal Engine 4 by using the UENUM macro and how to use bi-directional circular array indexing, which helps you iterate an array in both directions and loops around when you go beyond its index limits.

With the activity of this chapter complete, you'll have a basic playable game where players can shoot each other and switch weapons, but there is still more we can add to make it even more interesting.

In the next chapter, we'll learn where the instances of the most common gameplay framework classes exist in multiplayer, as well as learn about the Player State and Game State classes, which we haven't covered yet. We'll also cover some new concepts in the game mode that are used in multiplayer matches, as well as some useful general-purpose, built-in functionality.