Sorry your browser is not supported!

if ( dbMouseClick() == 1) 
		{		

			
			RigidBox* Temp = new RigidBox(dbMouseX(),dbMouseY(),50,i,2,&world);
			ListOfBoxes.push_back(*Temp);
			i++;
		}

  enum MouseState { BTN_RELEASED, BTN_PRESSED, BTN_ONCE };

  class CMouse {
    protected:
      MouseState m_Buttons[6]; /* Recognizes VK_LBUTTON/VK_RBUTTON/VK_XBUTTON1/VK_XBUTTON2 */
      int        m_PosX;       /* Current mouse position (screen coords) */
      int        m_PosY;       /* Current mouse position (screen coords) */
      int        m_PosZ;       /* Current mouse position (screen coords) */

      int        m_MoveX;      /* How much X coord has moved (screen coords) */
      int        m_MoveY;      /* How much Y coord has moved (screen coords) */
      int        m_MoveZ;      /* How much Z coord has moved (screen coords) */

      bool       m_IsVisible;    

    public:
      CMouse(void);
      ~CMouse(void);

      void Poll(void);

      void SetPosition( const int new_x, const int new_y ) {
        m_PosX = new_x; m_PosY = new_y;
        dbPositionMouse( new_x, new_y );
      }

      bool IsVisible( void ) const {
        return m_IsVisible;
      }

      void Show( void ) {
        m_IsVisible = TRUE;
        dbShowMouse();
      }

      void Hide( void ) {
        m_IsVisible = FALSE;
        dbHideMouse();
      }

      //********************************************************** 
      //  Since they are really just memory look-up, we want 
      //  these functions to be in-lined (if at a possible) to
      //  avoid any of the method/function call overhead...
      //********************************************************** 
      MouseState GetButtonState( const int btn ) const {
        MYASSERT(btn > 0);  /* VK_LMOUSE starts @ 1 */
        MYASSERT(btn < 7);  /* VK_XBUTTON2 ends @ 6 */
        return m_Buttons[btn-1];
      }

      bool ButtonUp( const int btn ) const {
        MYASSERT(btn > 0);  /* VK_LMOUSE starts @ 1 */
        MYASSERT(btn < 7);  /* VK_XBUTTON2 ends @ 6 */
        return (m_Buttons[btn-1] == BTN_RELEASED);
      }

      bool ButtonDown( const int btn ) const {
        MYASSERT(btn > 0);  /* VK_LMOUSE starts @ 1 */
        MYASSERT(btn < 7);  /* VK_XBUTTON2 ends @ 6 */
        return ((m_Buttons[btn-1] == BTN_PRESSED) || (m_Buttons[btn] == BTN_ONCE));
      }

      bool ButtonPressed( const int btn ) const {
        MYASSERT(btn > 0);  /* VK_LMOUSE starts @ 1 */
        MYASSERT(btn < 7);  /* VK_XBUTTON2 ends @ 6 */
        return (m_Buttons[btn-1] == BTN_PRESSED);
      }

      bool ButtonOnce( const int btn ) const {
        MYASSERT(btn > 0);  /* VK_LMOUSE starts @ 1 */
        MYASSERT(btn < 7);  /* VK_XBUTTON2 ends @ 6 */
        return (m_Buttons[btn-1] == BTN_ONCE);
      }

      int GetMouseMoveX( void ) const {
        return m_MoveX;
      }

      int GetMouseMoveY( void ) const {
        return m_MoveY;
      }

      int GetMouseMoveZ( void ) const {
        return m_MoveZ;
      }

      int GetMousePosX( void ) const {
        return m_PosX;
      }

      int GetMousePosY( void ) const {
        return m_PosY;
      }

      int GetMousePosZ( void ) const {
        return m_PosZ;
      }
  };

  CMouse::CMouse(void) : m_MoveX(0), m_MoveY(0), m_MoveZ(0), m_IsVisible(1) {
    memset(m_Buttons, 0, sizeof(MouseState)*6);   /* Set current state to RELEASED */
    dbShowMouse(); /* We default to Visible, so show the mouse */
  }

  CMouse::~CMouse(void) {
    memset(m_Buttons, 0, sizeof(MouseState)*6);  /* Set current state to RELEASED */
  }

  void CMouse::Poll(void) {
    SHORT btn;

    /* We're reading button states now - up to 6-buttons recognized */
    for (int x=VK_LBUTTON; x<=VK_XBUTTON2; x++) {
      /* 
        Don't really care for this, but dbMouseClick() doesn't seem to 
        recognize 4-buttons after all. My mouse has 5-buttons and only
        three are recognized, so we will use the GetAsyncKeyState()
        function to retrieve click-states for VK_LBUTTON, VK_RBUTTON,
        VK_XBUTTON1 and VK_XBUTTON2. Since these are recognized as 
        windows virtual-keys, we should have no problems getting them
        (if present) regardless of the mouse type we are using.
      */
      btn=GetAsyncKeyState(x);           

      if (btn & 0x8000) {                     /* Is the key currently pressed? */
        if (m_Buttons[x-1] == BTN_RELEASED) { /* Yes. Was it released before this check? */
          m_Buttons[x-1] = BTN_ONCE;          /* Yes. Flag as pressed ONCE - for this frame only */
        }
        else {
          m_Buttons[x-1] = BTN_PRESSED;       /* No. Was pressed last time - Still pressed! */
        }
      }
      else {
        m_Buttons[x-1] = BTN_RELEASED;        /* No. It's been released */
      }
    }

    //********************************************************** 
    //  TODO: 4/5/2010 - JWH - Verify that this will work
    //   correctly. That is, when reading dbMouseX(), dbMouseY()
    //   and dbMouseZ() - each of which are different functions,
    //   is it possible that the values can change before 
    //   completing the update cycle? What about the MouseMove()
    //   functions?
    //********************************************************** 

    /* Update the current position info */
    m_PosX = dbMouseX();
    m_PosY = dbMouseY();
    m_PosZ = dbMouseZ();   /* NOTE: This needs to reset to Zero after a period of inactivity */

    /* Update movement deltas */
    m_MoveX = dbMouseMoveX();
    m_MoveY = dbMouseMoveY();
    m_MoveZ = dbMouseMoveZ();
  }

  enum KeyState { KEY_RELEASED, KEY_PRESSED, KEY_ONCE };

  class CKeyboard {
    protected:
      KeyState m_Keys[256];

    public:
      CKeyboard(void);
      ~CKeyboard(void);

      void Poll(void);

      //********************************************************** 
      //  Since they are really just memory look-up, we want 
      //  these functions to be in-lined (if at a possible) to
      //  avoid any of the method/function call overhead...
      //********************************************************** 
      KeyState GetKeyState( const int key ) const {
        MYASSERT(key >= 0);
        MYASSERT(key < 256);
        return m_Keys[key];
      }

      bool KeyUp( const int key ) const {
        MYASSERT(key >= 0);
        MYASSERT(key < 256);
        return (m_Keys[key] == KEY_RELEASED);
      }

      bool KeyDown( const int key ) const {
        MYASSERT(key >= 0);
        MYASSERT(key < 256);
        return ((m_Keys[key] == KEY_PRESSED) || (m_Keys[key] == KEY_ONCE));
      }

      bool KeyPressed( const int key ) const {
        MYASSERT(key >= 0);
        MYASSERT(key < 256);
        return (m_Keys[key] == KEY_PRESSED);
      }

      bool KeyOnce( const int key ) const {
        MYASSERT(key >= 0);
        MYASSERT(key < 256);
        return (m_Keys[key] == KEY_ONCE);
      }
  };

  CKeyboard::CKeyboard(void) {memset(m_Keys, 0, sizeof(KeyState)*256);}   /* Set current state to RELEASED */
  CKeyboard::~CKeyboard(void) {memset(m_Keys, 0, sizeof(KeyState)*256);}  /* Set current state to RELEASED */

  void CKeyboard::Poll(void) {
    SHORT btn;

    /* We're reading button states now - up to 6-buttons recognized */
    for (int x=0; x<256; x++) {
      /* 
        Don't really care for this, but GetKeyboardState() doesn't update
        the key-states until after they are processed by the message-pump
        (WNDPROC).         
      */
      btn=GetAsyncKeyState(x);           

      if (btn & 0x8000) {                /* Is the key currently pressed? */
        if (m_Keys[x] == KEY_RELEASED) { /* Yes. Was it released before this check? */
          m_Keys[x] = KEY_ONCE;          /* Yes. Flag as pressed ONCE - for this frame only */
        }
        else {
          m_Keys[x] = KEY_PRESSED;       /* No. Was pressed last time - Still pressed! */
        }
      }
      else {
        m_Keys[x] = KEY_RELEASED;        /* No. It's been released */
      }
    }
  }

CKeyboard keyboard;
CMouse    mouse;

while (LoopGDK()) {
  keyboard.poll();
  mouse.poll();

  if (keyboard.KeyOnce(VK_SPACE) {
    // Do something only if the space key was just now pressed!
  }

  if (mouse.ButtonOnce(VK_LMOUSE) {
    // Do something only if the LEFT-mouse button was just now pressed!
  }
}

static bool bClick = false;
if ( dbMouseClick() == 1 )
    bClick = true;
if( dbMouseClick() != 1 && bClick )
{
    bClick = false;
    //do what you want
}

void gameTitle ( void )
{
	dbLoadImage("Images//Intro.jpg",37);
	dbSprite(1,0,0,37);

	keyboard.Poll();
	mouse.Poll();

	if(mouse.ButtonPressed(1))
	{
		g_eGameMode = eFireLevel;
		dbDeleteSprite(1);
	}

	dbSync ( );

}

 
While (loopgdk()) {
  Mouse.poll(); 
  
  If (mouse.buttononce(1))
   Dogamesetup(); 

  Dbsync(); 
}

	while ( LoopGDK ( ) )
	{
		game();
	
	}

void game(void)
{

	// lets find out which game mode we are in and call the appropiate routine
	// from here we can easily see the different parts that make up the game
	switch ( g_eGameMode )
	{
		// initial setting up of the game
		case eGameSetup:
			gameSetup(); break;


		// display the main title screen
		case eGameTitle:
			gameTitle(); break;



		// the game itself!
		case eFireLevel:
			FireLevel(); break;

		// player has completed a level!
		case eGameWin:
			gameWin(); break;
		
		
		// player has lost all lives, Game Over!
		case eGameOver:
			gameOver(); break;
	}


}

/* Globals... */
enum  eMode { eGameSetup , eGameTitle , eGamePlay ,  eGameWin , eGameOver };
eMode g_eGameMode = eGameSetup;

CKeyboard keyboard;
CMouse    mouse;

/* Other globals your code needs... */
...

void DarkGDK(void) {
  /* Window setup code here... */
  ...

  dbLoadImage("Images//Intro.jpg",37);

  while (LoopGDK()) {
    /* Read Keyboard/Mouse for this frame */
    keyboard.Poll();
    mouse.Poll();

    /* 
      Now that input-states have been captured, process them by
      checking the current state of the game and handling any
      user-requests for that state...
    */
    game();

    /* This frame is finished, render it to the screen */
    dbSync();
    
  }

}

void game( )
{

	// lets find out which game mode we are in and call the appropiate routine
	// from here we can easily see the different parts that make up the game
	switch ( g_eGameMode )
	{
	// initial setting up of the game
	case eGameSetup:
		gameSetup(); break;


	// display the main title screen
	case eGameTitle:
		gameTitle(); break;



	// the game itself!
	case eGamePlay:
		gamePlay(); break;

	// player has completed a level!
	case eGameWin:
		gameWin(); break;

	
	
	// player has lost all lives, Game Over!
	case eGameOver:
		gameOver(); break;
	}


}

/* Here's the important one... */
void gameTitle ( void )
{
	/* load it once before here... */
        // dbLoadImage("Images//Intro.jpg",37);
	dbSprite(1,0,0,37);

   /* 
     NOTE: You've already poll()'d the keyboard/mouse, so you
     don't need to do it again
   */
   // keyboard.Poll();
   // mouse.Poll();

	if(mouse.ButtonOnce(1))
	{
		g_eGameMode = eFireLevel;
		dbDeleteSprite(1);
	}

    /* 
      NOTE: You can dbSync() here if you want, but I would wait
      until the entire frame has been drawn first, which would be
      complete by the bottom of the LoopGDK() above...
    */
    
}

void gameTitle ( void )
{
	dbLoadImage("Images//Intro.jpg",37);
	dbSprite(56,0,0,37);

	
		if(mouse.ButtonPressed(1))
		{
			g_eGameMode = eFireLevel;
			dbDeleteSprite(56);
			bTitle = false;
		}


}

void gameTitle ( void )
{
	dbLoadImage("Images//Intro.jpg",37);
	dbSprite(56,0,0,37);

	bool bTitle = true;

	 while (bTitle)
	 {
		keyboard.Poll();
	    mouse.Poll();

		if(mouse.ButtonPressed(1))
		{
			dbDeleteSprite(56);
			bTitle = false;
			g_eGameMode = eFireLevel;
		}

		dbSync ( );
	 }


}

// one time game setup on first run, load in everything we need
void gameSetup ( void )
{
	dbSetDisplayMode (800 ,600, 32);
	dbSetWindowPosition(wPosX,wPosY);

	worldAABB.lowerBound.Set(wPosX,wPosY); 
	worldAABB.upperBound.Set(dbScreenWidth()/b2PixelRatio, dbScreenHeight()/b2PixelRatio);
	m_ContactListener = new ContactListener;

	world = new b2World(worldAABB, gravity, doSleep);

	//dbSprite(2,-100,-100,3);
	
	world->SetContactListener(m_ContactListener);

/////Load title images here////////////
dbLoadImage("Images//Intro.jpg",37);
dbSprite(56,0,0,37);
	

	// switch to game title mode
	g_eGameMode = eGameTitle;
}

void gameTitle ( void )
{

		if(mouse.ButtonPressed(1))
		{
			dbDeleteSprite(56);
			bTitle = false;
			g_eGameMode = eFireLevel;
		}

		
}


}

// the main entry point for the application is this function
void DarkGDK ( void )
{
	dbSyncOn   ( );
	dbSyncRate ( 60 );


	while ( LoopGDK ( ) )
	{
		
		
		keyboard.Poll();
	    mouse.Poll();
	
		game();	

		float32 timeStep = 1.0f /60.0f;
		int32 iterations = 10;
		world->Step(timeStep,iterations);

		   dbSync ();


		
	}

	delete world;
	delete m_ContactListener;

	//return back to windows
	return;
}


// the game loop
void game(void)
{

	// lets find out which game mode we are in and call the appropiate routine
	// from here we can easily see the different parts that make up the game
	switch ( g_eGameMode )
	{
		// initial setting up of the game
		case eGameSetup:
			gameSetup(); break;


		// display the main title screen
		case eGameTitle:
			gameTitle(); break;



		// the game itself!
		case eFireLevel:
			FireLevel(); break;

		// player has completed a level!
		case eGameWin:
			gameWin(); break;
		
		
		// player has lost all lives, Game Over!
		case eGameOver:
			gameOver(); break;
	}


}

// one time game setup on first run, load in everything we need
void gameSetup ( void )
{
	dbSetDisplayMode (800 ,600, 32);
	dbSetWindowPosition(wPosX,wPosY);

	worldAABB.lowerBound.Set(wPosX,wPosY); 
	worldAABB.upperBound.Set(dbScreenWidth()/b2PixelRatio,       dbScreenHeight()/b2PixelRatio);
	m_ContactListener = new ContactListener;

	world = new b2World(worldAABB, gravity, doSleep);

	//dbSprite(2,-100,-100,3);
	
	world->SetContactListener(m_ContactListener);

/////Load title images here////////////
dbLoadImage("Images//Intro.jpg",37);
dbSprite(56,0,0,37);
	

	// switch to game title mode
	g_eGameMode = eGameTitle;
}

void gameTitle ( void )
{

		if(mouse.ButtonPressed(1))
		{
			dbDeleteSprite(56);
			//bTitle = false;
			g_eGameMode = eFireLevel;
			FireLevelSetup(world,box);
			Guy = new Character(50,450,5,1,2,world);
			Fire = new        Element(126,262,100,40,38,world);
}

		



}



 void FireLevel ( void )
{
	bool bPlay = true;


		Guy->Update(&keyboard, &mouse, world); 
		Fire->Update();

		for (int i = 0; i < 29; i++)
		{
				box[i]->Update();
		}
	

	
}