5 replies to this topic

[BosseBL]

So I have started working on a light weight "engine" to help me design a game easy and got an idea that I want some guidance with.
To explain my idea, let us take an input manager for example. I would like to be able to store events and functions together in the following way:

class InputManager {

private:
map<int eventID, void(*function)()> eventActions

public:
void bind(int eventID, void(*function)());
void handleEvent();
};

so that I can write the actual game code in the form of a bunch of functions that I can bind to an event. Then all I have to do is call the handleEvent(), and it will detect events and call their corresponding function.

What I don't get is how I would go by and organize the code so that all functions I write has access to all the resources like TextureManager, SoundManager, EntityManager.

Is this possible to do?
Is it a good way of coding games?
Can I do it better differently?

thx for all the answers and sorry for a somewhat misleading title.

Edited by BosseBL, 13 June 2012 - 05:29 AM.

[Waterlimon]

You should also make the event pass the object which linked to it to the function, so instead of calling a function you can use it to call a member function of an object or something (not sure how it works)

You could use it like .BindEvent(eventID,MyObject,MyObject::MemberFunction) i think.

[larspensjo]

What I don't get is how I would go by and organize the code so that all functions I write has access to all the resources like TextureManager, SoundManager, EntityManager.

This doesn't sound as a good start. "All functions having access to all resources".

A strategy to get a good design is to limit access as much as possible. That means that a change will have less impact.

[larspensjo]

Have a look at the Model-View-Controller (MVC) pattern.

A basic idea is that there is a model of the game (the objects in it, and how they interact). Then the "View" reads out the state of the Model and presents it to the player. That would be sound and graphics. That way, the Model needs not to know anything about sound and graphics. The Controller takes care of the input, and tells the Model to act accordingly.

[SiCrane]

Instead of storing function pointers consider storing function objects like boost::/std::function. Then events that need external resources can bind them to the function object. Ex: using boost::/std::bind.

[Bregma]

It looks like you're using C++.

Instead of reinventing what already comes with C++, you could just use it.

#include <map>
#include <functional>

class TextureManager;
class SoundManager;
class EntityManager;
typedef int EventId;

typedef std::function<void (TextureManager&, SoundManager&, EntityManager&)> EventHandler;
typedef std::map<EventId, EventHandler> EventHandlerMap;

Then you can use std::bind to associate free functions, member functions, functors, or whatever to your event IDs, and you can also curry additional parameters as necessary.

EventHandlerMap eventHandlerMap;
TouchReaction	touchReactor;

eventHandlerMap[EVENT_TOUCH_BEGIN] = std::bind(&TouchReaction::begin, touchReactor, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

//...

EventHandlerMap::iterator it = eventHandlerMap.find(eventId);
if (it != eventHandlerMap.end())
{
  it->second(texturemanager, soundManager, entityManager);
}

You will need a compiler that adheres to at least this part of the current C++ standard -- most compiler makers have one available.