A dead simple implementation looks like:

```

// simple

void InputHandler::handleInput()

{

  if (isPressed(BUTTON_X)) jump();

  else if (isPressed(BUTTON_Y)) fireGun();

  else if (isPressed(BUTTON_A)) swapWeapon();

  else if (isPressed(BUTTON_B)) lurchIneffectively();

}

// command pattern

class Command

{

public:

  virtual ~Command() {}

  virtual void execute() = ;

  //virtual void execute(Actor *) = 0;

};

class JumpCommand : public Command

{

public:

  virtual void execute() { jump(); }

};

class FireCommand : public Command

{

public:

  virtual void execute() { fireGun(); }

};

class InputHandler

{

public:

  void handleInput();

  // Methods to bind commands...

private:

  Command* buttonX_;

  Command* buttonY_;

  Command* buttonA_;

  Command* buttonB_;

};

Command* InputHandler::handleInput()

{

  if (isPressed(BUTTON_X)) return buttonX_;

  if (isPressed(BUTTON_Y)) return buttonY_;

  if (isPressed(BUTTON_A)) return buttonA_;

  if (isPressed(BUTTON_B)) return buttonB_;

  // Nothing pressed, so do nothing.

  return NULL;

}

Command* command = inputHandler.handleInput();

if (command)

{

  command->execute(actor);

}

```

#### use command stream, decoupled producer and consumer

## undo and redo

```

class Command

{

public:

  virtual ~Command() {}

  virtual void execute() = ;

  virtual void undo() = ;

};

class MoveUnitCommand : public Command

{

public:

  MoveUnitCommand(Unit* unit, int x, int y)

  : unit_(unit),

    xBefore_(),

    yBefore_(),

    x_(x),

    y_(y)

  {}

  virtual void execute()

  {

    // Remember the unit's position before the move

    // so we can restore it.

    xBefore_ = unit_->x();

    yBefore_ = unit_->y();

    unit_->moveTo(x_, y_);

  }

  virtual void undo()

  {

    unit_->moveTo(xBefore_, yBefore_);

  }

private:

  Unit* unit_;

  int xBefore_, yBefore_;

  int x_, y_;

};

```