Game engine event handling

Great teacher with a pleasant dose of humor. Adding an Event Manager. Enroll for Free. This Course Video Transcript. Delegates and Event Handlers UnityEvent and UnityAction Fish Revenge Adding an Event Manager Follow Us. Chat in the GameDev.

Published June 12, One of the more common questions asked on the GDNet technical forums relates to handling input in a game engine. Typically, there's a few core issues that pretty much every game faces, and unlike many areas of game implementation, input is one where we can more or less build a one-size-fits-all framework.

Fortunately, this is a pretty straightforward thing to do, and even is portable across APIs and platforms pretty easily. For the purposes of this article, we'll focus on the platform-independent side of things.

For other platforms, research and select the API or library of your choice. Got a way to get pure input data? Let's take a look at the overall input system architecture. Designing a Robust Input Handling System We have a few goals here which should make this system or ones based on it applicable for pretty much any game, from a simple 2D platformer to an RTS to a 3D shooter: Performance is important; input lag is a bad thing.

It should be easy to have new systems tap into the input stream. The system must be very flexible and capable of handling a wide variety of game situations. Configurability input mapping is essential for modern games. Thankfully, we can hit all of these targets with fairly minimal effort.

Input mapping and dispatch to the correct high-level handlers High level handler code The first layer we have already decided to gloss over; its specifics aren't terribly important. What matters is that you have a way to pump pure input data into the second layer, which is where most of the interesting stuff happens.

Finally, the third layer will implement your specific game's responses to the input it receives. Contexts The central concept of this system is the input context. A context defines what inputs are available for the player at a given time.

For instance, you may have a different context for when a game menu is open versus when the game is actually being played; or different modes might require different contexts. Think of games like Final Fantasy where you have a clear division between moving around the game world and combat, or the Battlefield series where you get a different set of controls when flying a helicopter versus when running around on the ground.

Contexts consist of three different types of input: Actions States Ranges An action is a single-time thing, like casting a spell or opening a door; generally if the player just holds the button down, the action should only happen once, generally when the button is first pressed, or when it is finally released.

States are similar, but designed for continuous activities, like running or shooting. A state is a simple binary flag: either the state is on, or it's off. When the state is active, the corresponding game action is performed; when it is not active, the action is not performed.

Simple as that. Other good examples of states include things like scrolling through menus. Finally, a range is an input that can have a number value associated with it.

For simplicity, we will assume that ranges can have any value; however, it is common to define them in normalized spans, e. We'll see more about the specifics of range values later. Ranges are most useful for dealing with analog input, such as joysticks, analog controller thumbsticks, and mice.

Input Mapping The next feature we'll look at is input mapping. Simply put, this is the process of going from a raw input datum to an action, state, or range.

In terms of implementation, input mapping is very simple: each context defines an input map. The goal is simply to take an identified type of hardware input and convert it to the final type of input. One twist here is that we might need to handle things like key-repeat, joysticks, and so on. It is especially important to have a mapping layer that can handle ranges intelligently, if we need normalized range values in the high-level game logic and I strongly recommend using normalized values anywhere possible.

They can range from something as general as keyboard input or the application window closing to something as specific as a weapon being fired in a game. I do not know which EventHandler would want to react to which and how many types of events. The reason I'm buffering the events instead of processing them directly is because in order to keep performance of my game engine steady, processes might need to be scheduled. Interface and access controll : You're absolutely right.

However one "dispatcher queue" might make the entire idea of scheduling event processing difficult and does not solve the problem I'm currently facing. Also the optimization of reducing the number of queues mind that they only hold pointers to my events, there is no costly copying here seems really low-level and is propably not the most pressing issue with my current code.

The example code given, where the events have to outlive the event handler to hide this problem, is absurd. Thanks for the reminder! Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog. Stack Gives Back Safety in numbers: crowdsourcing data on nefarious IP addresses. Featured on Meta. New post summary designs on greatest hits now, everywhere else eventually.

Related 1. Hot Network Questions. Question feed. Bind and receive global messages. Unbind and Unbind all is also supported. Methods for debugging and managing the global events are also included. No need to create Components or Interfaces. Based on Game Instance Subsystem. So no need to initialize anything. The system will automatically "clean" itself when Actors are destroyed or when the level is destroyed.

Documentation: Link ExampleProject: 4.