main_options.cpp

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#include "utils.h"
#include "defs.h"
#include "audio.h"
#include "video.h"
#include "script.h"
#include "mode_manager.h"
#include "input.h"
#include "system.h"
#include "global.h"
#include "main_options.h"

using namespace std;
using namespace hoa_utils;

namespace hoa_main {

bool ParseProgramOptions(int32 &return_code, int32 argc, char **argv) {
  // Convert the argument list to a vector of strings for convenience
  vector<string> options(argv, argv + argc);
  return_code = 0;

  for (uint32 i = 1; i < options.size(); i++) {
    if (options[i] == "-c" || options[i] == "--check") {
      if (CheckFiles() == true) {
        return_code = 0;
      }
      else {
        return_code = 1;
      }
      return false;
    }
    else if (options[i] == "-d" || options[i] == "--debug") {
      if ((i + 1) >= options.size()) {
        cerr << "Option " << options[i] << " requires an argument." << endl;
        PrintUsage();
        return_code = 1;
        return false;
      }
      if (EnableDebugging(options[i + 1]) == false) {
        return_code = 1;
        return false;
      }
      i++;
    }
    else if (options[i] == "-h" || options[i] == "--help") {
      PrintUsage();
      return_code = 0;
      return false;
    }
    else if (options[i] == "-i" || options[i] == "--info") {
      if (PrintSystemInformation() == true) {
        return_code = 0;
      }
      else {
        return_code = 1;
      }
      return false;
    }
    else if (options[i] == "-r" || options[i] == "--reset") {
      if (ResetSettings() == true) {
        return_code = 0;
      }
      else {
        return_code = 1;
      }
      return_code = 0;
      return false;
    }
    else if (options[i] == "-t" || options[i] == "--test") {
      if ((i + 1) >= options.size()) {
        cerr << "Option " << options[i] << " requires an argument." << endl;
        PrintUsage();
        return_code = 1;
        return false;
      }
      // TODO: convert options[i+1] from a string to a number and call test code
//      if (DEBUG_TestCode(options[i + 1]) == false) {
//        return_code = 1;
//        return false;
//      }
      i++;
    }
    else if (options[i] == "-v" || options[i] == "--version") {
      if (IsLatestVersion())
        cout << "This is the latest version of Allacrost" << endl;
      else
        cout << "A newer version of Allacrost (" << GetLatestVersion() << ") is available!" << endl;
      return false;
    }
    else {
      cerr << "Unrecognized option: " << options[i] << endl;
      PrintUsage();
      return_code = 1;
      return false;
    }
  }

  return true;
} // bool ParseProgramOptions(int32_t &return_code, int32_t argc, char **argv)



// Prints out the usage options (arguments) for running the program (work in progress)
void PrintUsage() {
  cout << "usage: allacrost [options]" << endl;
  cout << "  --check/-c        :: checks all files for integrity" << endl;
  cout << "  --debug/-d <args> :: enables debug statements in specifed sections of the" << endl;
  cout << "                       program, where <args> can be:" << endl;
  cout << "                       all, audio, battle, boot, data, global, input," << endl;
  cout << "                       map, mode_manager, pause, quit, scene, system" << endl;
  cout << "                       utils, video" << endl;
  cout << "  --help/-h         :: prints this help menu" << endl;
  cout << "  --info/-i         :: prints information about the user's system" << endl;
  cout << "  --reset/-r        :: resets game configuration to use default settings" << endl;
  cout << "  --test/-t <arg>   :: executes requested testing code and then exits" << endl;
  cout << "  --version/-v      :: checks for newer versions of Allacrost online" << endl;
}


// EnableDebugging enables various debugging print statements in different parts of the game
bool EnableDebugging(string vars) {
  if (vars.empty()) {
    cerr << "ERROR: debug specifier string is empty" << endl;
    return false;
  }

  // A vector of all the debug arguments
  vector<string> args;

  // Find the first non-whitespace character
  uint32 sbegin = 0;
  while (vars[sbegin] == ' ' || vars[sbegin] == '\t') {
    sbegin++;
    if (sbegin >= vars.size()) {
      cerr << "ERROR: no white-space characters in debug specifier string" << endl;
      return false;
    }
  }

  // Parse the vars string on white-space characters and fill the args vector
  // TODO: this loop needs to be made more robust to errors
  for (uint32 i = sbegin; i < vars.size(); i++) {
    if (vars[i] == ' ' || vars[i] == '\t') {
      args.push_back(vars.substr(sbegin, i - sbegin));
      sbegin = i + 1;
    }
  }
  args.push_back(vars.substr(sbegin, vars.size() - sbegin));

  // Enable all specified debug variables
  for (uint32 i = 0; i < args.size(); i++) {
    if (args[i] == "all") {
      // This causes every call to SDL_SetError to also print an error message on stderr.
      // NOTE: commented out because apparently SDL_putenv is not yet an available function on some systems
      // SDL_putenv("SDL_DEBUG=1");

      hoa_audio::AUDIO_DEBUG                  = true;
      hoa_battle::BATTLE_DEBUG                = true;
      hoa_boot::BOOT_DEBUG                    = true;
      hoa_script::SCRIPT_DEBUG                = true;
      hoa_mode_manager::MODE_MANAGER_DEBUG    = true;
      hoa_input::INPUT_DEBUG                  = true;
      hoa_system::SYSTEM_DEBUG                = true;
      hoa_global::GLOBAL_DEBUG                = true;
      hoa_map::MAP_DEBUG                      = true;
      hoa_menu::MENU_DEBUG                    = true;
      hoa_pause::PAUSE_DEBUG                  = true;
      hoa_quit::QUIT_DEBUG                    = true;
      hoa_shop::SHOP_DEBUG                    = true;
      hoa_scene::SCENE_DEBUG                  = true;
      hoa_utils::UTILS_DEBUG                  = true;
      hoa_video::VIDEO_DEBUG                  = true;
    }
    else if (args[i] == "audio") {
      hoa_audio::AUDIO_DEBUG = true;
    }
    else if (args[i] == "battle") {
      hoa_battle::BATTLE_DEBUG = true;
    }
    else if (args[i] == "boot") {
      hoa_boot::BOOT_DEBUG = true;
    }
    else if (args[i] == "data") {
      hoa_script::SCRIPT_DEBUG = true;
    }
    else if (args[i] == "mode_manager") {
      hoa_mode_manager::MODE_MANAGER_DEBUG = true;
    }
    else if (args[i] == "input") {
      hoa_input::INPUT_DEBUG = true;
    }
    else if (args[i] == "system") {
      hoa_system::SYSTEM_DEBUG = true;
    }
    else if (args[i] == "global") {
      hoa_global::GLOBAL_DEBUG = true;
    }
    else if (args[i] == "map") {
      hoa_map::MAP_DEBUG = true;
    }
    else if (args[i] == "menu") {
      hoa_menu::MENU_DEBUG = true;
    }
    else if (args[i] == "pause") {
      hoa_pause::PAUSE_DEBUG = true;
    }
    else if (args[i] == "quit") {
      hoa_quit::QUIT_DEBUG = true;
    }
    else if (args[i] == "scene") {
      hoa_scene::SCENE_DEBUG = true;
    }
    else if (args[i] == "shop") {
      hoa_shop::SHOP_DEBUG = true;
    }
    else if (args[i] == "utils") {
      hoa_utils::UTILS_DEBUG = true;
    }
    else if (args[i] == "video") {
      hoa_video::VIDEO_DEBUG = true;
    }
    else {
      cerr << "ERROR: invalid debug argument: " << args[i] << endl;
      return false;
    }
  } // for (uint32 i = 0; i < args.size(); i++)

  return true;
} // bool EnableDebugging(string vars)


// Prints version numbers for SDL libraries, video rendering information, and other info
//  about the user's system (work in progress)
bool PrintSystemInformation() {
  printf("\n===== System Information\n");

  // Initialize SDL and its subsystems and make sure it shutdowns properly on exit
  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) != 0) {
    cerr << "ERROR: Unable to initialize SDL: " << SDL_GetError() << endl;
    return false;
  }
  atexit(SDL_Quit);

  printf("SDL version (compiled):  %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
  printf("SDL version (linked):    %d.%d.%d\n", SDL_Linked_Version()->major, SDL_Linked_Version()->minor, SDL_Linked_Version()->patch);

  SDL_Joystick *js_test;
  int32 js_num = SDL_NumJoysticks();
  printf("Number of joysticks found:  %d\n", js_num);
  for (int32 i = 0; i < js_num; i++) { // Print out information about each joystick
    printf("  Joystick #%d\n", i);
    printf("    Joystick Name: %s\n", SDL_JoystickName(i));
    js_test = SDL_JoystickOpen(i);
    if (js_test == NULL)
      printf("    ERROR: SDL was unable to open joystick #%d!\n", i);
    else {
      printf("    Number Axes: %d\n", SDL_JoystickNumAxes(js_test));
      printf("    Number Buttons: %d\n", SDL_JoystickNumButtons(js_test));
      printf("    Number Trackballs: %d\n", SDL_JoystickNumBalls(js_test));
      printf("    Number Hat Switches: %d\n", SDL_JoystickNumHats(js_test));
      SDL_JoystickClose(js_test);
    }
  }

  printf("\n===== Video Information\n");

  // TODO: This code should be re-located to a function (DEBUG_PrintInfo()) in the video engine
//  hoa_video::VideoManager = hoa_video::GameVideo::SingletonCreate();
//  if (hoa_video::VideoManager->SingletonInitialize() == false) {
//    cerr << "ERROR: unable to initialize the VideoManager" << endl;
//    return false;
//  }
//  else {
//    hoa_video::VideoManager->DEBUG_PrintInfo();
//  }
//  hoa_video::GameVideo::SingletonDestroy();

  // TODO: print the OpenGL version number here

  printf("SDL_ttf version (compiled): %d.%d.%d\n", SDL_TTF_MAJOR_VERSION, SDL_TTF_MINOR_VERSION, SDL_TTF_PATCHLEVEL);
  // printf("SDL_ttf version (linked):   %d.%d.%d\n", Ttf_Linked_Version()->major, Ttf_Linked_Version()->minor, Ttf_Linked_Version()->patch);

  char video_driver[80];
  SDL_VideoDriverName(video_driver, 80);
  printf("Name of video driver: %s\n", video_driver);

  const SDL_VideoInfo *user_video;
  user_video = SDL_GetVideoInfo(); // Get information about the user's video system
  cout << "  Best available video mode" << endl;
  cout << "    Creates hardware surfaces: ";
  if (user_video->hw_available == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Has window manager available: ";
  if (user_video->wm_available == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Hardware to hardware blits accelerated: ";
  if (user_video->blit_hw == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Hardware to hardware colorkey blits accelerated: ";
  if (user_video->blit_hw_CC == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Hardware to hardware alpha blits accelerated: ";
  if (user_video->blit_hw_A == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Software to hardware blits acceleerated: ";
  if (user_video->blit_sw == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Software to hardware colorkey blits accelerated: ";
  if (user_video->blit_sw_CC == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Software to hardware alpha blits accelerated: ";
  if (user_video->blit_sw_A == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Color fills accelerated: ";
  if (user_video->blit_fill == 1) cout << "yes\n";
  else cout << "no\n";
  cout << "    Total video memory: " << user_video->video_mem << " kilobytes" << endl;
  // cout << "    Best pixel format: " << user_video->vfmt << endl;

  printf("\n===== Audio Information\n");

  hoa_audio::AudioManager = hoa_audio::GameAudio::SingletonCreate();
  if (hoa_audio::AudioManager->SingletonInitialize() == false) {
    cerr << "ERROR: unable to initialize the AudioManager" << endl;
    return false;
  }
  else {
    hoa_audio::AudioManager->DEBUG_PrintInfo();
  }
  hoa_audio::GameAudio::SingletonDestroy();

  printf("\n");

  return true;
} // bool PrintSystemInformation()


// Resets the game settings to default.
bool ResetSettings() {
  cerr << "This option is not yet implemented." << endl;

  // And then if they say yes, we overwrite the user prefs file with the default prefs file
  return false;
} // bool ResetSettings()



// NOTE: the following function contains operating system dependant code
// Prints any bad file checks (work in progress)
bool CheckFiles() {
  cout << "This option is not yet implemented." << endl;
  return false;
} // bool CheckFiles()



void DEBUG_TestCode(uint32 code) {
  // Default test message
  if (code == 0) {
    cout << "0: This is not a real test code id, it just prints this message" << endl;
  }

  // NOTE: All code cases require a comment describing what the test involves
//  else if (code == 1) {
//    do_something
//  }


  else {
    cerr << "MAIN ERROR: no definition for test code id number: " << code << endl;
  }
} // void DEBUG_TestCode(uint32 code)

} // namespace hoa_main

---