cgame.cpp

#include "globals.h"

#include "cevent.h"
#include "cgame.h"
#include "cdebug.h"
#include "ctimer.h"
#include "cvideo.h"

#include <assert.h>

//#include <ruby.h>

CGame *CGame::unique_instance = 0;

/* Returns true if the game quit flag has been activated. */
int CGame::is_game_quit()
{
  return quit_flag;
}

/* Quit the game.  This should be called by a game state when it wants the game
   to quit, so that everything is properly shut down upon exit.  This is done by
   setting the game quit flag to TRUE; the game loop checks the value of this flag
   each time around, and if it has been activated, the game deinitializes. */
void CGame::quit()
{
  quit_flag = 1;
}

void CGame::do_draw(CSurface &surface, CRect &rect) {
  surface.fill_rect(rect, 0);
}

/* Draw the current frame. */
void CGame::draw_frame()
{
  CScreen &screen = CVideoSystemManager::get_instance().get_screen();

  /* Remove all consecutive rectangles on our update list. */
  dirty_rects.unique();

  for (CRectList::iterator i = dirty_rects.begin(); i != dirty_rects.end(); i++) {
    screen.set_clipping_rect(*i);
    draw(screen, *i);
  }

  screen.update_rects(dirty_rects);

  dirty_rects.clear();
}

int CGame::do_handle_event(CEvent &event)
{
        /* If the game state's controller doesn't handle the input,
                        we'll deal with it ourselves. */
  switch (event.get_type()) {
                        /* If the user presses "f", show framerate info. */
      case CEvent::TYPE_KEY_DOWN:
        switch (event.get_key_ascii_value()) {
                                        case 'f':
                                                /* If the user pressed CTRL-F, toggle fullscreen mode,
                                                                otherwise just toggle display of the game's
                                                                framerate statistics. */
            if (event.is_ctrl_pressed()) {
              CScreen &s = CVideoSystemManager::get_instance().get_screen();

              s.set_fullscreen_mode(!s.get_fullscreen_mode());
              return 1;
                                                }
                                                break;
                                }
                                break;
                        /* If the user uses the OS or GUI to stop the program,
                                        e.g. by clicking the game window's close box, then quit. */
      case CEvent::TYPE_APPLICATION_EXIT:
                                quit();
        return 1;
                }
    return 0;
}

/* Run the game.  This is the main "game loop". */
void CGame::run()
{
  timer.restart();

        while ( !is_game_quit() ) {
    CEvent *event = CEventSystemManager::get_instance().get_next_event();

                /* Process input using a basic "chain of responsibility" pattern. */
                if (event) {
      handle_event(*event);
      delete event;
    }

                /* Process the model of the current game state. */
    for (std::list<ITickable *>::iterator i = tickables.begin(); i != tickables.end(); i++) {
      (*i)->tick(timer.get_time_passed());
    }

                /* Draw the current frame. */
                draw_frame();

                /* Update framerate and other "passage of time"-related information. */
    timer.update();
        }
}

/* Initialize the game. */
CGame::CGame(CSystemFactorySet *driver) : timer(TempGameConstants::GAME_MAX_FRAME_TIME)
{
  using namespace TempGameConstants;
  //ruby_init();
  //ruby_script("embedded");

  CVideoSystemManager::init(driver->videoFactory);
  CEventSystemManager::init(driver->eventFactory);
  CTimerSystemManager::init(driver->timerFactory);

  /* \todo figure out a way to encapsulate this into the cscreen object so that
     when the screen size changes, this is automatically changed too... maybe
     make cscreen a descendant of CModel so we have a pub/sub system? */
  CScreen &screen = CVideoSystemManager::get_instance().get_screen();
  CRect screen_size = CRect(0, 0, screen.get_width(), screen.get_height());
  this->set_bounding_rect(screen_size);

  quit_flag = 0;

  font_large = new CFont(GAME_FONT_BIG_FILENAME, GAME_FONT_BIG_CHAR_WIDTH,
    GAME_FONT_BIG_CHAR_HEIGHT, GAME_FONT_BIG_CHARS_PER_LINE);

  font_small = new CFont(GAME_FONT_SMALL_FILENAME, GAME_FONT_SMALL_CHAR_WIDTH,
    GAME_FONT_SMALL_CHAR_HEIGHT, GAME_FONT_SMALL_CHARS_PER_LINE);
}

/* Shut down the game. */
CGame::~CGame()
{
  delete font_large;
  delete font_small;

  CTimerSystemManager::deinit();
  CEventSystemManager::deinit();

  CVideoSystemManager::deinit();  
}

void CGame::init(CSystemFactorySet *driver)
{
  unique_instance = new CGame(driver);
}

void CGame::deinit()
{
  delete unique_instance;
}

---