DirectInput Problem

    
/****************************************************************************
 InputSystem.h
 
 Declaration of a DirectInput class wrapper input system 
  
 Author   :   Dave Astle
 Date     :   3/5/2001

 Written for OpenGL Game Programming
*****************************************************************************/
#ifndef __INPUT_SYSTEM_INCLUDED__
#define __INPUT_SYSTEM_INCLUDED__
#define DIRECTINPUT_VERSION 0x0800

/********************************* Includes *********************************/
#include <dinput.h>


/********************************* Constants ********************************/
#define IS_USEKEYBOARD  1
#define IS_USEMOUSE     2


class CKeyboard
{
public:
  CKeyboard(LPDIRECTINPUT8 pDI, HWND hwnd);
  ~CKeyboard();

  bool  KeyDown(char key) { return (m_keys[key] & 0x80) ? true : false; }
  bool  KeyUp(char key) { return (m_keys[key] & 0x80) ? false : true; }

  bool  Update();

  void  Clear() { ZeroMemory(m_keys, 256 * sizeof(char)); }

  bool  Acquire();
  bool  Unacquire();

private:
  LPDIRECTINPUTDEVICE8  m_pDIDev;

  char    m_keys[256];
};


class CMouse
{
public:
  CMouse(LPDIRECTINPUT8 pDI, HWND hwnd, bool isExclusive = true);
  ~CMouse();

  bool  ButtonDown(int button) { return (m_state.rgbButtons[button] & 0x80) ? true : false; }
  bool  ButtonUp(int button) { return (m_state.rgbButtons[button] & 0x80) ? false : true; }
  int   GetWheelMovement() { return m_state.lZ; }
  void  GetMovement(int &dx, int &dy) { dx = m_state.lX; dy = m_state.lY; }

  bool  Update();

  bool  Acquire();
  bool  Unacquire();

private:
  LPDIRECTINPUTDEVICE8  m_pDIDev;
  DIMOUSESTATE          m_state;
};


class CInputSystem
{
public:
  bool  Initialize(HWND hwnd, HINSTANCE appInstance, bool isExclusive, DWORD flags = 0);
  bool  Shutdown();

  void  AcquireAll();
  void  UnacquireAll();

  CKeyboard  *GetKeyboard() { return m_pKeyboard; }
  CMouse     *GetMouse()    { return m_pMouse; }

  bool  Update();

  bool  KeyDown(char key) { return (m_pKeyboard && m_pKeyboard->KeyDown(key)); }
  bool  KeyUp(char key) { return (m_pKeyboard && m_pKeyboard->KeyUp(key)); }

  bool  ButtonDown(int button) { return (m_pMouse && m_pMouse->ButtonDown(button)); }
  bool  ButtonUp(int button) { return (m_pMouse && m_pMouse->ButtonUp(button)); }
  void  GetMouseMovement(int &dx, int &dy) { if (m_pMouse) m_pMouse->GetMovement(dx, dy); }
  int   GetMouseWheelMovement() { return (m_pMouse) ? m_pMouse->GetWheelMovement() : 0; }

private:
  CKeyboard  *m_pKeyboard;
  CMouse     *m_pMouse;
  
  LPDIRECTINPUT8 m_pDI;
};

#include "InputSystem.cpp"
#endif //__INPUT_SYSTEM_INCLUDED__

  

  
 
/****************************************************************************
 InputSystem.cpp
 
 Implementation of a DirectInput class wrapper input system 
  
 Author   :   Dave Astle
 Date     :   3/5/2001

 Written for OpenGL Game Programming
*****************************************************************************/
#include "InputSystem.h"


/*****************************************************************************
 CKeyboard::Constructor

 Initializes the DI device
*****************************************************************************/
CKeyboard::CKeyboard(LPDIRECTINPUT8 pDI, HWND hwnd)
{
  if (FAILED(pDI->CreateDevice(GUID_SysKeyboard, &m_pDIDev, NULL)))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->SetDataFormat(&c_dfDIKeyboard)))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE)))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->Acquire()))
  {
    // error processing
  }

  Clear();
} // end CKeyboard::Constructor


/*****************************************************************************
 CKeyboard::Destructor

 Releases the DI device
*****************************************************************************/
CKeyboard::~CKeyboard()
{
  if (m_pDIDev)
  {
    m_pDIDev->Unacquire();
    m_pDIDev->Release();
  }
} // end CKeyboard::Destructor


/*****************************************************************************
 CKeyboard::Update()

 Queries the current state of the keyboard and stores it in the member
 variables.
*****************************************************************************/
bool CKeyboard::Update()
{
  if (FAILED(m_pDIDev->GetDeviceState(sizeof(m_keys), (LPVOID)m_keys)))
  {
    if (FAILED(m_pDIDev->Acquire()))
    {
      return false;
    }
    if (FAILED(m_pDIDev->GetDeviceState(sizeof(m_keys), (LPVOID)m_keys)))
    {
      return false;
    }
  }
  return true;
} // end CKeyboard::Update()


/*****************************************************************************
 CKeyboard::Acquire()

 Acquires the keyboard
*****************************************************************************/
bool CKeyboard::Acquire()
{
  Clear();
  return (!FAILED(m_pDIDev->Acquire()));
} // end CKeyboard::Acquire()


/*****************************************************************************
 CKeyboard::Unacquire()

 Unacquires the keyboard
*****************************************************************************/
bool CKeyboard::Unacquire()
{
  Clear();
  return (!FAILED(m_pDIDev->Unacquire()));
} // end CKeyboard::Unacquire()



/*****************************************************************************
 CMouse::Constructor

 Initializes the DI device
*****************************************************************************/
CMouse::CMouse(LPDIRECTINPUT8 pDI, HWND hwnd, bool isExclusive)
{
  if (FAILED(pDI->CreateDevice(GUID_SysMouse, &m_pDIDev, NULL)))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->SetDataFormat(&c_dfDIMouse)))
  {
    // error processing
  }

  DWORD flags;
  if (isExclusive)
    flags = DISCL_FOREGROUND | DISCL_EXCLUSIVE | DISCL_NOWINKEY;
  else
    flags = DISCL_FOREGROUND | DISCL_NONEXCLUSIVE;


  if (FAILED(m_pDIDev->SetCooperativeLevel(hwnd, flags)))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->Acquire()))
  {
    // error processing
  }

  if (FAILED(m_pDIDev->GetDeviceState(sizeof(DIMOUSESTATE), &m_state)))
  {
    // error processing
  }
} // end CMouse::Constructor


/*****************************************************************************
 CMouse::Destructor

 Releases the DI device
*****************************************************************************/
CMouse::~CMouse()
{
  if (m_pDIDev)
  {
    m_pDIDev->Unacquire();
    m_pDIDev->Release();
  }
} // end CMouse::Destructor


/*****************************************************************************
 CMouse::Update()

 Queries the current state of the mouse and stores it in the member
 variables.
*****************************************************************************/
bool CMouse::Update()
{
  if (FAILED(m_pDIDev->GetDeviceState(sizeof(DIMOUSESTATE), &m_state)))
  {
    if (FAILED(m_pDIDev->Acquire()))
    {
      return false;
    }
    if (FAILED(m_pDIDev->GetDeviceState(sizeof(DIMOUSESTATE), &m_state)))
    {
      return false;
    }
  }

  return true;
} // end CMouse::Update()


/*****************************************************************************
 CMouse::Acquire()

 Acquires the mouse
*****************************************************************************/
bool CMouse::Acquire()
{
  return (!FAILED(m_pDIDev->Acquire()));
} // end CMouse::Acquire


/*****************************************************************************
 CMouse::Unacquire()

 Unacquires the keyboard
*****************************************************************************/
bool CMouse::Unacquire()
{
  return (!FAILED(m_pDIDev->Unacquire()));
} // end CMouse::Unacquire()


/*****************************************************************************
 CInputSystem::Initialize()

 Initializes the input system. isExclusive should be set to true for exclusive
 mouse access, false otherwise. Flags should be a combination of
 IS_USEKEYBOARD and/or IS_USEMOUSE.
*****************************************************************************/
bool CInputSystem::Initialize(HWND hwnd, HINSTANCE appInstance, bool isExclusive, DWORD flags)
{

  //Do something pointless to shut up the compiler (warning)
  if(flags!=flags)
  	flags = flags;
  // create the DI object
  if (FAILED(DirectInput8Create(appInstance,
                               DIRECTINPUT_VERSION,
                               IID_IDirectInput8,
                               (void **)&m_pDI,
                               NULL)))
    return false;

  if(true)
  {
    m_pKeyboard = new CKeyboard(m_pDI, hwnd);
    if (m_pKeyboard == NULL)
      return false;
  }
  if(true)
  {
    m_pMouse = new CMouse(m_pDI, hwnd, isExclusive);
    if (m_pMouse == NULL)
      return false;
  }

  return true;
} // end CInputSystem::Initialize()


/*****************************************************************************
 CInputSystem::Shutdown()

 Releases all objects and frees memory.
*****************************************************************************/
bool CInputSystem::Shutdown()
{
  UnacquireAll();
  if (m_pKeyboard)
  {
    delete m_pKeyboard;
    m_pKeyboard = NULL;
  }

  if (m_pKeyboard)
  {
    delete m_pMouse;
    m_pMouse = NULL;
  }

  if (FAILED(m_pDI->Release()))
    return false;

  return true;
} // end CInputSystem::Shutdown()


/*****************************************************************************
 CInputSystem::Update()

 Queries the current state of all devices.
*****************************************************************************/
bool CInputSystem::Update()
{
  if (m_pKeyboard)
    m_pKeyboard->Update();
  if (m_pMouse)
    m_pMouse->Update();

  return true;
} // end CInputSystem::Update()


/*****************************************************************************
 CInputSystem::AcquireAll()

 Makes sure all input devices are acquired
*****************************************************************************/
void CInputSystem::AcquireAll()
{
  if (m_pKeyboard)
    m_pKeyboard->Acquire();
  if (m_pMouse)
    m_pMouse->Acquire();
} // end CInputSystem::AcquireAll()


/*****************************************************************************
 CInputSystem::UnacquireAll()

 Unacquires all devices
*****************************************************************************/
void CInputSystem::UnacquireAll()
{
  if (m_pKeyboard)
    m_pKeyboard->Unacquire();
  if (m_pMouse)
    m_pMouse->Unacquire();
} // end CInputSystem::UnacquireAll()


  

  
// Check For Key Presses

if(inputSys->KeyDown(DIK_UP))
	MoveEntity(player, BWM_UP);
	
if(inputSys->KeyDown(DIK_DOWN))
	MoveEntity(player, BWM_UP);
	
if(inputSys->KeyDown(DIK_LEFT))
	MoveEntity(player, BWM_UP);
	
if(inputSys->KeyDown(DIK_RIGHT))
	MoveEntity(player, BWM_UP);