Game programming event handling

Now the only common code knowledge by two unrelated classes that want to be able to communicate with each other is just this class definition, that's it. After a chain of if-else casting, the proper handling method is called. In the above example event handling method name depends on event type it handles but using overloading and templates can simplify this code a bit:.

Also, events are full-fledged objects now. The if-else chain has also the same drawback as switch statement: it is not reusable. The only one thing that the event handling class is aware of is a stable never changing base event class and concrete message classes that it has interest in.

The idea is to derive concrete event types from the base class Event and register member functions to handle that event in EventHandler class instance. EventHandler is responsible for mapping from the type of event to the proper method that handles that event. Here is the code:. Small but powerful, its purpose is registering actual event handling methods for specific event types.

After receiving a generic event of type Event it determines its actual type and then calls the proper handler method with valid event as a parameter. As you can see, mapping is made between TypeInfo objects and pointers to HandlerFunctionBase instances. Using standard map as the mapping method ensures logarithmic handler identification. EventHandler class stores all event handling methods and corresponding instance pointers in classes derived from HandlerFunctionBase.

Concrete derivatives store member function pointers for different specific event types and are also responsible for proper down-casting to actual event types when calling the handling method. However, as one of the reviewers pointed out, that kind of templates use leads to 'code bloat'. This basically means that the compiler has more work to do since it has to generate valid instantiations of MemberFunctionHandler for every event handling method, resulting in increased compilation times and probably a larger executable but in contrast, this is the way that one would normally implement polymorphic callbacks.

Also, there is one more virtual function call overhead per handler - but again, test for fifteen different event types all derived directly from Event class so just if-else vs. The included demo code shows the last presented solution in action: it creates a Monster and a Tank instance and then forces them to respond to concrete events that my happen to them in a dangerous game world.

Monster class publicly inherits from EventHandler class but Tank is using a nested private class and aggregation to hide its handling methods from the outside world. This idea just popped in to my head a few days ago so it may not be perfect, still I hope you like it. Feel free to contact me at szymon-dot-gatner-at-gmail-dot-com. In this chapter, you will learn about Events, its types, and also learn how to handle an event.

Example is provided at the end of the chapter for better understanding. Change in the state of an object is known as Event , i. Events are generated as a result of user interaction with the graphical user interface components.

For example, clicking on a button, moving the mouse, entering a character through keyboard, selecting an item from the list, and scrolling the page are the activities that causes an event to occur. They are generated as consequences of a person interacting with the graphical components in the Graphical User Interface.

For example, clicking on a button, moving the mouse, entering a character through keyboard, selecting an item from list, scrolling the page, etc. Operating system interrupts, hardware or software failure, timer expiration, and operation completion are some examples of background events. Event Handling is the mechanism that controls the event and decides what should happen if an event occurs.

This mechanism has a code which is known as an event handler, that is executed when an event occurs. Java uses the Delegation Event Model to handle the events. This model defines the standard mechanism to generate and handle the events.

Source is responsible for providing information of the occurred event to it's handler. Learn about game development. Follow Us. Chat in the GameDev. Back to General and Gameplay Programming. Simple Event Handling Programming. General and Gameplay Programming. Do you see issues with this article? Let us know. Introduction I recently wrote a simple event handling module for a group project. I found it to be quite a useful tool, and I'm writing this article so that hopefully others may find it useful as well.

Our group project was implemented by five programmers, each writing a different component of the game. The need for event handling arose when different components each needed to know about certain types of input mainly keyboard and mouse events , but didn't need to know about the underlying lower-level implementation. For example, components needed to know when a key corresponding to a certain action was pressed such as the "jump" key , but didn't want to know which actual key was pressed.

From that arose this simple event dispatching and handling system. The goals for this system where three-fold: A simple system to use and setup Relatively quick we don't want to send events about everything Object-oriented given that it had to fit in with the rest of the project The rest of the article will step through each part of the system, explaining the implementation, as well as making suggestions for improvements. The Type variable will indicate what type of event the structure refers to.

The two arg variables are simply arguments to be passed along with the structure. When this system was first being designed, the only events to be passed around were mouse movement events needing an x and y coordinates as arguments , and key press events needing the key being pressed as an argument.

A possible improvement here is to pass around a pointer to an Event class instead of a structure. The Event class could then contain any amount of information, and derived classes could be created for different types of events. I choose a simpler option, mainly because the scope of our project didn't require such a complex solution.

The Event. Type variable is used by event handlers to identify the event. I choose to define the type of events in an enumeration structure. A typical implementation of this method will have a switch statement switching on the Event.