Input/Command Design

In my game I''ve done something more like 2. It seems to make sense to have the config resposible for key mapping in case the user wants to have a selection of key mappings to choose from. Either way should be equally efficient though, it''s a question of choice.

Mark

Hi

I dont really know if this helps but in my rpg engine i am devolping i have a CommandManager singleton class which is responsible for handling commands and the keys that generate them - Now this is how it works, i have a structure declared as:

struct SCommandKeyBind{
ICommand* pCommand;
int Key;
IGameObject pDest;
}

ICommand is an abstract base class that allows diferent commands to be derived (for example ShootCommand and MoveCommand). pDest is the destination for the command if null all objects in the game will recieve notification of the command

during the initailastion of the engine it calls the command managers RegisterCommand method with a structure of the above
which states which command is bound to which key.

For example if a players Shoot command was bound to space it could be added as so:

SCommandKeyBind new_command;

new_command.pCommand = new CFireCommand(); //derived from ICommand
new_command.Key = KEY_SPACE;
new_command.pDest = CEdenEngine::GetInstance()->GetPlayer();
CCommandManager::GetInstance()->RegisterCommand(&new_command);

Now during the game when the lower level input system fires an event to my main engine class - the engine class first looks at the input values and if it isnt any predefined system ones (for example in my engine X means shutdown) if not it shoves it off to the command manager to foreword to whovever neeeds it, for example he is some hypothetical code:

void CEdenEngine::OnKeyboardInterupt(int InputValue)
{
if(!CheckIfSystemCode(InputValue))
{
CCommandManager::GetInstance()->HandleInput(InputValue);
}
else
{
HandleSystemCode(InputValue);
}
}


now the command managers code may look something like this:

CCommandManager::HandleInput(InputValue)
{

// get the command from the list based on the key pressed   
SCommandKeyBind* pCommandBind = FetchCommand(InputValue);

//to avoid coupling the command to the receiver we
//pass the object the command should do something with
//as a param to command this means command can be
// made more flexible

// if there are NULL receivers we broadcast it to everyone
if(pCommandBind->pDest==NULL)
{
BroadCastCommandToAll(pCommandBind->pCommand);
}
else
{
pCommandBind->pCommand->Execute(pCommandBind->pDest);
}


}


 

So in short the commmand manager, well manages the commands and knows how to pass them on but doesnt have a clue what the command actually does, it only knows the destination (one object or all objects tbh you could improve this to allow object filters etc) and how to execute it.

The main engine traps any commands that are important system commands first and them allows the command manager to handle any.